mutable
A Database System for Research and Fast Prototyping
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 Cconst_virtual_crtp_helper:: returns:: crtp_args:: args
 Cconst_virtual_crtp_helper:: returns:: crtp_args:: args
 Cconst_virtual_crtp_helper:: returns:: crtp_args:: args
 Cconst_virtual_crtp_helper:: returns:: crtp_args:: args
 Cconst_virtual_crtp_helper:: returns:: crtp_args:: args
 Cm::__virtual_crtp_helper< Tag, Const >A helper class to introduce a virtual method overload per type to a class hierarchy
 Cm::wasm::_int< W >Helper type to deduce the signed integral type with a given byte width
 Cm::wasm::_int< 1 >
 Cm::wasm::_int< 2 >
 Cm::wasm::_int< 4 >
 Cm::wasm::_int< 8 >
 Cm::wasm::detail::_var_helper< T >Deduces a suitable specialization of Variable that can be NULL for the given type
 Cm::wasm::detail::_var_helper< Expr< T, L > >
 Cm::wasm::detail::_var_helper< PrimitiveExpr< T, L > >
 Cm::memory::AddressSpaceThis class represents a reserved address space in virtual memory
 Cm::AdjacencyMatrixAn adjacency matrix for a given query graph
 Caggregate_info_t

‍helper struct for aggregates

 Cm::allocator< Actual >
 Cm::memory::AllocatorThis is the common interface for all memory allocators that support rewiring
 Cm::wasm::Allocator
 Cm::allocator< list_allocator >
 Cm::allocator< malloc_allocator >
 Cm::pe::hs::config::anytime_search< B >
 Cm::ArgParserA parser for command line arguments
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >
 Cargs_t
 Cm::detail::as_tuple< T >Static cast of
 Cm::detail::as_tuple< param_pack_t< Ts... > >Specialization for
 CASTClauseVisitor
 CASTCommandVisitor
 CASTConstraintVisitor
 CASTExprVisitor
 Cm::AttributeAn attribute of a table
 Cm::ast::CreateTableStmt::attribute_definition
 Cavg_aggregate_info_t

‍helper struct for AVG aggregates

 Cm::pe::hs::heuristics::avg_sel< PlanTable, State, Expand >
 Cm::pe::hs::heuristics::avg_sel< PlanTable, State, BottomUp >
 Cm::BackendDefines the interface of all execution Backends
 Ccalculate_filter_cost_tag::base_type
 Ccalculate_grouping_cost_tag::base_type
 Ccalculate_join_cost_tag::base_type
 Cenumerate_tag::base_type
 Cestimate_join_all_tag::base_type
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::base_type_helper< C, T, Ts >
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::base_type_helper< false, T >
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::base_type_helper< true, T >
 Cm::pe::hs::config::beam< Num, Denom >
 Cm::Spn::ContinuousLeaf::Bin
 Cm::Spn::DiscreteLeaf::Bin
 Cm::wasm::Bit
 Cm::Block< N >A block of size N contains N tuples
 Cm::wasm::BlockRepresents a code block, i.e
 Cm::Block< 64 >
 Cm::wasm::BlockUserA helper class to use a Block, thereby setting the Block active for code generation
 Cm::pe::hs::expansions::BottomUp
 Cm::pe::hs::heuristics::bottomup_lookahead_cheapest< PlanTable, State >
 Cm::wasm::branch_target_tStores the "branch targets" introduced by control flow structures, i.e
 Cm::wasm::Buffer< IsGlobal >Buffers tuples by materializing them into memory
 Cm::wasm::buffer_load_proxy_t< IsGlobal >Proxy to implement loads from a buffer
 Cm::wasm::buffer_storage< IsGlobal >
 Cm::wasm::buffer_storage< false >
 Cm::wasm::buffer_storage< true >
 Cm::wasm::buffer_store_proxy_t< IsGlobal >Proxy to implement stores to a buffer
 Cm::wasm::buffer_swap_proxy_t< IsGlobal >Proxy to implement swaps in a buffer
 Cm::CartesianProductEstimatorDummyEstimator that always returns the size of the cartesian product of the given subproblems
 Cm::CatalogThe catalog contains all Databases and keeps track of all meta information of the database system
 Cm::wasm::chained_hash_table_storage< IsGlobal >
 Cm::wasm::chained_hash_table_storage< false >
 Cm::wasm::chained_hash_table_storage< true >
 Cv8_inspector::V8Inspector::Channel
 Cm::storage::DataLayout::INode::child_t

‍a child Node and its relative offset and stride within the containing INode

 Cm::Spn::Product::ChildWithVariables
 Cm::Spn::Sum::ChildWithWeight
 Cm::ast::Clause
 Cm::ClauseInfoCollects information of a cnf::Clause
 Cm::wasm::CodeGenContextThe Wasm CodeGenContext provides context information necessary for code generation
 Cm::term::ColorWrapper class to ease the use of terminal colors (foreground and background)
 Cm::ast::Command
 Cm::SerialScheduler::CommandQueueA thread-safe query plan queue
 Cm::common_type< T, U >Computes the common type of
 Cm::common_type< T, T >Specialization for equal types
 Cm::common_type< T, U >If both
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >::comparator

‍comparator for map entries based on states' g + h value

 Cm::Concat< T, Args >
 Cm::Concat< std::variant< Args0... >, Args1... >
 Cm::Condition
 Cm::detail::condition_entry_t< Entry >Helper struct to unite ConditionSets and entries of type
 Cm::detail::condition_entry_t< entry_type >
 Cm::conditional_one< Cond, TrueType, FalseType >
 Cm::conditional_one< false, TrueType, FalseType >
 Cstd::conditional_t
 Cm::ConditionPropertyMap< Property, Ordered >
 Cm::ConditionPropertyMap< Order >
 Cm::ConditionSet
 Cm::DSVReader::ConfigConfiguration parameters for importing a DSV file
 Cm::WebSocketServer::Connection
 Cm::storage::DataLayout::INode::const_iterator
 Cm::wasm::ConstantFoldingHelper struct to perform constant folding at compile time
 CConstASTClauseVisitor
 Cast::ConstASTCommandVisitor
 CConstASTCommandVisitor
 CConstASTConstraintVisitor
 Cast::ConstASTExprVisitor
 CConstASTExprVisitor
 CConstOperatorVisitor
 CConstPostOrderOperatorVisitor
 Cm::ast::ConstraintAbstract class to represent constraints attached to attributes of a table
 CConstTypeVisitor
 Cm::pe::hs::config::cost_based_pruning< B >
 Cm::CostModelFactory
 Cm::crtp< ConcreteType, CRTPBaseType, TParams >A helper class to define CRTP class hierarchies
 Cm::crtp< Actual, Base >
 Cm::crtp< Actual, PhysicalOperator, Pattern >
 Cm::crtp< Actual, PhysicalPlanTable, Condition2EntryMap >
 Cm::crtp< Actual, PlanTableBase >
 Cm::crtp< ConcretePhysicalPlanTable, PhysicalPlanTable, ConcreteCondition2PPTEntryMap >
 Cm::crtp< ConcreteVisitor, Visitor, Base >
 Cm::crtp< EdgePtrBottomUp, Base >
 Cm::crtp< EdgesBottomUp, Base >
 Cm::crtp< PlanTableLargeAndSparse, PlanTableBase >
 Cm::crtp< PlanTableSmallOrDense, PlanTableBase >
 Cm::crtp< SubproblemsArray, Base >
 Cm::crtp< SubproblemTableBottomUp, Base >
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >
 Cm::crtp_boolean< ConcreteType, CRTPBaseType, B, TParams >A helper class to define CRTP class hierarchies with an additional boolean template parameter (this is often used for iterators taking a boolean template parameter to decide on constness)
 Cm::crtp_boolean< Actual, the_condition_entry_iterator, C, Entry >
 Cm::crtp_boolean< Actual< C >, the_condition_entry_iterator, C, Entry >
 Cm::crtp_boolean< ConcretePhysicalPlanTableIterator< Ref, C >, the_condition_entry_iterator, C, ConcretePhysicalPlanTableEntry >
 Cm::crtp_boolean_templated< ConcreteType, CRTPBaseType, It, TParams >A helper class to define CRTP class hierarchies with an additional boolean template template parameter (this is often used for iterators taking a boolean template parameter to decide on constness)
 Cm::crtp_boolean_templated< Actual, Condition2PPTEntryMap, It, Entry >
 Cm::crtp_boolean_templated< Actual, PhysicalPlanTableEntry, ChildIt >
 Cm::crtp_boolean_templated< ConcreteCondition2PPTEntryMap, Condition2PPTEntryMap, detail::Condition2PPTEntryMapIterator, ConcretePhysicalPlanTableEntry >
 Cm::crtp_boolean_templated< ConcretePhysicalPlanTableEntry, PhysicalPlanTableEntry, detail::PhysicalPlanTableEntryChildIterator >
 Cm::DatabaseA Database is a set of Tables, Functions, and Statistics
 Cm::DatabaseCommandThe command pattern for operations in the DBMS
 Cm::storage::DataLayoutModels how data is laid out in a linear address space
 Cm::storage::DataLayoutFactoryThis is an interface for factories that compute particular DataLayouts for a given sequence of Types, e.g
 Cm::DataModelA DataModel describes a data set
 Cm::DataSourceA DataSource in a QueryGraph
 Cm::Pool< T, Hash, KeyEqual, ThreadSafe >::dereference_equal_to
 Cm::Pool< T, Hash, KeyEqual, ThreadSafe >::dereference_hash
 Ccalculate_filter_cost_tag::derived_type
 Ccalculate_grouping_cost_tag::derived_type
 Ccalculate_join_cost_tag::derived_type
 Cenumerate_tag::derived_type
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::derived_type_helper< C, Actual, T, Ts >
 Cm::Diagnostic
 Cm::DotToolThis class enables direct rendering of dot output (e.g
 Cm::doubly_linked_list< T, Allocator >Implements a doubly-linked list with an overhead of just a single pointer per element
 Cm::doubly_linked_list< size_type, list_allocator_proxy >
 Cm::dyn_array< T >Implements an array of dynamic but fixed size
 Cm::RefCountingHashMap< Key, Value, Hash, KeyEqual >::entry_type
 Cm::Schema::entry_type
 Cm::wasm::EnvironmentBinds Schema::Identifiers to Expr<T>s
 Cstd::exceptionSTL class
 Cm::ast::ExprAn expression
 Cm::wasm::Expr< typename, size_t >
 Cm::wasm::expr< T >Helper type to deduce the Expr<U> type given a
 Cm::wasm::Expr< Base >
 Cm::wasm::expr< detail::the_reference< T, L, IsConst > >Specialization for
 Cm::wasm::expr< Expr< T, L > >Specialization for
 Cm::wasm::expr< Parameter< T, L > >Specialization for
 Cm::wasm::expr< PrimitiveExpr< T, L > >Specialization for
 Cm::wasm::expr< T >Specialization for decayable
 Cm::wasm::Expr< T, L >An Expr<T, L> combines a PrimitiveExpr<T, L> value with a PrimitiveExpr<bool, L>, called NULL information, to implement a value with three-valued logic (3VL)
 Cm::wasm::expr< Variable< T, Kind, CanBeNull, L > >Specialization for
 Cwasm::ModuleRunner::ExternalInterface
 Cstd::false_type
 Cm::pe::hs::config::Fibonacci_heap
 Cm::ast::FromClause::from_type
 Cm::FunctionDefines a function
 Cm::wasm::Function< typename >Represents a Wasm function
 Cstd::function
 Cm::wasm::Function< PrimitiveExpr< void, 1 >(PrimitiveExpr< ParamTypes, ParamLs >...)>
 Cm::wasm::FunctionProxy< typename >A handle to create a Function and to create invocations of that function
 Cm::wasm::FunctionProxy< PrimitiveExpr< void, 1 >(PrimitiveExpr< ParamTypes, ParamLs >...)>
 Cm::wasm::GarbageCollectedDataHelper struct for garbage collection done by the Module
 Cm::ai::genericAStar< State, Expand, Heuristic, StaticConfig, Context >Implements a generic A* search algorithm
 Cm::get_nodes< Op >
 Cm::get_nodes< pattern_t< Op, Children... > >
 Cm::get_singleton_operator< typename >
 Cm::get_singleton_operator< Op >
 Cm::get_singleton_operator< pattern_t< Op, Wildcard > >
 Cm::get_singleton_operator< pattern_t< Op, Wildcard, Wildcard > >
 Cm::get_tm
 Cm::wasm::detail::global_helper< T >Deduces a suitable specialization of Variable for global variables of the given type
 Cm::wasm::detail::global_helper< PrimitiveExpr< T, L > >
 Cm::pe::hs::heuristics::GOO< PlanTable, State, BottomUp >
 Cm::pe::GOO< PlanTable, State, Expand::direction >
 Cm::pe::hs::heuristics::GOO< PlanTable, State, TopDown >Inspired by GOO: Greedy Operator Ordering
 Cm::GospersHackEnumerate all subsets of size k based on superset of size n
 Cm::gs::GridSearch< Spaces >
 Cstd::hash< Container >
 Cstd::hash< m::ast::Expr >Specialization of std::hash to m::ast::Expr
 Cstd::hash< m::Attribute >Specializes std::hash<T> for m::Attribute
 Cstd::hash< m::cnf::Predicate >
 Cstd::hash< m::pe::hs::search_states::EdgePtrBottomUp >
 Cstd::hash< m::pe::hs::search_states::EdgesBottomUp >
 Cstd::hash< m::pe::hs::search_states::SubproblemsArray >
 Cstd::hash< m::pe::hs::search_states::SubproblemTableBottomUp >
 Cstd::std::hash< m::Pooled< T, Pool, CanBeNone > >
 Cstd::hash< m::Schema::Identifier >Specializes std::hash<T> for m::Schema::Identifier
 Cstd::hash< m::Tuple >
 Cstd::hash< m::Type >
 Cstd::hash< m::Value >
 Cstd::hash< std::reference_wrapper< T > >Convenience specialization to provide hashing of std::reference_wrapper by hashing the referenced object
 Cm::wasm::HashTableHash table to hash key-value pairs in memory
 Cm::Schema::IdentifierAn Identifier is composed of a name and an optional prefix
 Cm::ConditionPropertyMap< Property, Ordered >::IdentifierHash
 Cm::wasm::If
 Cm::Database::index_entry_type
 Cindex_scan_bounds_t

‍helper struct holding the bounds for index scan

 Cm::idx::IndexBaseThe base class for indexes
 Cm::InjectionCardinalityEstimatorInjectionCardinalityEstimator that estimates cardinalities based on a table that contains sizes for the given subproblems Table is initialized in the constructor by using an external json-file If no entry is found, uses the DummyEstimator to return an estimate
 Cm::wasm::invoke_interpreter< typename >
 Cm::wasm::invoke_v8< typename >
 Cstd::ios_baseSTL class
 Cm::wasm::is_sql_addr_type< typename >
 Cm::wasm::is_sql_type< typename >
 Cm::SmallBitset::iterator
 Cm::JoinA Join in a QueryGraph combines DataSources by a join condition
 Cm::pe::hs::config::lazy< B >
 Cm::lazy_construct< Factory >
 Cm::storage::DataLayout::leaf_info_t

‍combines information of a single leaf for for_sibling_leaves()

 Cm::Spn::LearningData
 Cm::storage::DataLayout::level_info_t

‍combines information of a single internal level inside the DataLayout, used by for_sibling_leaves()

 Cm::ast::Lexer
 Cm::idx::RecursiveModelIndex< Key >::LinearModel
 Cm::LinearModelA model for predicting the costs of a physical operator
 Cm::wasm::detail::local_bit_storage< L >Helper class to select appropriate storage for a LocalBit
 Cm::wasm::detail::local_bit_storage< 1 >Specialization for a single bit
 Cm::wasm::LocalBit< size_t >
 Cm::wasm::LocalBitmap
 Cm::wasm::LocalBitvector
 Cm::wasm::LoopImplements a loop which iterates exactly once unless explicitly continue-ed
 Cm::Match< T >
 Cm::MatchBase
 Cm::Timer::Measurement
 Cm::memory::MemoryRepresents a mapping created by a memory::Allocator
 Cm::MinCutAGaT
 Cm::wasm::Module
 Cm::pe::hs::config::monotone< B >
 Cm::pe::GOO::node
 Cm::Spn::Node
 Cm::storage::DataLayout::Node

‍an abstract node in the recursive data layout model

 Cm::doubly_linked_list< T, Allocator >::node_type
 Cm::wasm::open_addressing_hash_table_layout< ValueInPlace >
 Cm::wasm::open_addressing_hash_table_layout< false >
 Cm::wasm::open_addressing_hash_table_layout< true >
 Cm::wasm::open_addressing_hash_table_storage< IsGlobal >
 Cm::wasm::open_addressing_hash_table_storage< false >
 Cm::wasm::open_addressing_hash_table_storage< true >
 Cm::OperatorAn Operator represents an operation in a query plan
 Cm::OperatorDataThis interface allows for attaching arbitrary data to Operator instances
 Cm::OperatorInformationThis class provides additional information about an Operator, e.g
 Cm::OptField< Condition, T >
 Cm::OptField< false, m::reader_writer_mutex >
 Cm::OptField< false, T >
 Cm::OptField< StaticConfig::PerformAnytimeSearch, uint64_t >
 Cm::OptField< StaticConfig::PerformCostBasedPruning, double >
 Cm::OptField< StaticConfig::PerformCostBasedPruning, std::vector< std::pair< m::SmallBitset, m::SmallBitset > > >
 Cm::OptField< StaticConfig::PerformWeightedSearch, float >
 Cm::OptField< ThreadSafe, m::reader_writer_mutex >
 Cm::OptimizerThe optimizer interface
 Cm::ArgParser::Option
 Cm::OptionsSingleton class representing options provided as command line argument to the binaries
 Cm::PairHash< T1, T2, H1, H2 >Computes the XOR-hash for a pair
 Cm::wasm::Parameter< typename, size_t >
 Cm::ast::Parser
 Cm::PartialPlanGeneratorA partial plan is a set of (potentially incomplete) pairwise disjoint plans
 Cm::partition_predicated_naivePartitions the range begin to end (exclusive) into two partitions using pivot
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >::Partitions< Partition >
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >::Partitions< false >
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >::Partitions< supports_partitioning< State, Context... > >
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >::Partitions< true >
 Cm::pattern_matcher_baseAbstract base class of all matchable patterns
 Cm::pattern_matcher_recursive< PhysOp, Idx, PatternQueue >
 Cm::pattern_matcher_recursive< PhysOp, Idx, Op, PatternQueue... >
 Cm::pattern_matcher_recursive< PhysOp, Idx, pattern_t< Op, Children... >, PatternQueue... >
 Cm::pattern_t< Op, Children >
 Cm::PhysicalOperator< Aggregation, AggregationOperator >
 Cm::PhysicalOperator< Callback< SIMDfied >, CallbackOperator >
 Cm::PhysicalOperator< Filter< Predicated >, FilterOperator >
 Cm::PhysicalOperator< HashBasedGrouping, GroupingOperator >
 Cm::PhysicalOperator< HashBasedGroupJoin, pattern_t< GroupingOperator, pattern_t< JoinOperator, Wildcard, Wildcard > > >
 Cm::PhysicalOperator< IndexScan< IndexMethod >, pattern_t< FilterOperator, ScanOperator > >
 Cm::PhysicalOperator< LazyDisjunctiveFilter, DisjunctiveFilterOperator >
 Cm::PhysicalOperator< Limit, LimitOperator >
 Cm::PhysicalOperator< NestedLoopsJoin< Predicated >, JoinOperator >
 Cm::PhysicalOperator< NoOp, NoOpOperator >
 Cm::PhysicalOperator< NoOpSorting, SortingOperator >
 Cm::PhysicalOperator< OrderedGrouping, GroupingOperator >
 Cm::PhysicalOperator< Print< SIMDfied >, PrintOperator >
 Cm::PhysicalOperator< Projection, ProjectionOperator >
 Cm::PhysicalOperator< Quicksort< CmpPredicated >, SortingOperator >
 Cm::PhysicalOperator< Scan< SIMDfied >, ScanOperator >
 Cm::PhysicalOperator< SimpleHashJoin< UniqueBuild, Predicated >, pattern_t< JoinOperator, Wildcard, Wildcard > >
 Cm::PhysicalOperator< SortMergeJoin< SortLeft, SortRight, Predicated, CmpPredicated >, pattern_t< JoinOperator, Wildcard, Wildcard > >
 Cm::PhysicalOptimizerThe physical optimizer interface
 Cm::PlanTableDecorator< Actual >
 Cm::PlanTableEntry
 Cm::PlanTableEntryDataThis interface allows for attaching arbitrary data to PlanTableEntry instances
 Cm::PODPool< T, Hash, KeyEqual, Copy, ThreadSafe >The PODPool implements an implicitly garbage-collected set of pooled (or internalized) POD struct entities
 Cm::PODPool< const char *, StrHash, StrEqual, StrClone, false >
 Cm::PODPool< const char *, StrHash, StrEqual, StrClone, ThreadSafe >
 Cm::Pool< T, Hash, KeyEqual, ThreadSafe >A pool implements an implicitly garbage-collected set of instances of a class hierarchy
 Cm::Pool< m::Type >
 Cm::Pooled< T, Pool, CanBeNone >A data type representing a pooled (or internalized) object
 Cm::Position
 Cm::cnf::PredicateA Predicate contains a Expr of Boolean type in either positive or negative form
 Cm::wasm::primitive_expr< T >Helper type to deduce the PrimitiveExpr<U> type given a type
 Cm::wasm::primitive_expr< detail::the_reference< T, L, IsConst > >Specialization for
 Cm::wasm::primitive_expr< Parameter< T, L > >Specialization for
 Cm::wasm::primitive_expr< PrimitiveExpr< T, L > >Specialization for
 Cm::wasm::primitive_expr< T >Specialization for decayable
 Cm::wasm::primitive_expr< Variable< T, Kind, false, L > >Specialization for
 Cm::wasm::PrimitiveExpr< typename, size_t >
 Cm::wasm::PrimitiveExpr< bool, 1 >
 Cm::wasm::PrimitiveExpr< bool, L >
 Cm::wasm::PrimitiveExpr< T *, L >
 Cm::wasm::PrimitiveExpr< T, L >
 Cprint_info
 Cm::wasm::print_types< Ts, Ls >A helper type to print Wasm types
 Cm::wasm::print_types< param_pack_t< T >, L >Prints the Wasm type for
 Cm::wasm::print_types< param_pack_t< T, Ts... >, L, Ls... >Prints the Wasm type for
 Cm::wasm::OpenAddressingHashTableBase::ProbingStrategyProbing strategy to handle collisions in an open addressing hash table
 Cm::pe::hs::heuristics::product< PlanTable, State, Expand >This heuristic estimates the distance from a state to the nearest goal state as the product of the sizes of all Subproblems yet to be joined
 Cm::pe::hs::heuristics::product< PlanTable, State, BottomUp >
 Cm::projecting_iterator< It, Fn, OwnsProjection >
 Cm::projecting_iterator< It, ReturnType &(It), OwnsProjection >
 Cm::AdjacencyMatrix::Proxy< C >A proxy to access single entries in the AdjacencyMatrix
 Cm::SmallBitset::Proxy< C >A proxy to access single elements in SmallBitset
 CPtr
 Cm::wasm::detail::ptr_helper< T >
 Cm::wasm::detail::ptr_helper< PrimitiveExpr< T, L > >
 Cm::wasm::detail::ptr_helper< void >
 Cm::put_timepoint< Clock, Duration >
 Cm::put_tm
 Cm::QueryGraphThe query graph represents all data sources and joins in a graph structure
 Cm::range< It >
 Cm::read_lock
 Cm::ReaderAn interface for all readers
 Cm::reader_writer_lockThis is a helper class that helps managing reader and writer locks claimed from reader_writer_mutex
 Cm::reader_writer_mutexImplements a many-readers, single-writer locking concept
 Cm::detail::reader_writer_mutex_internalNOTE: This class is not thread-safe
 Cm::RefCountingHashMap< Key, Value, Hash, KeyEqual >
 Cm::ast::Sema::RequireContextHelper class to create a context when one is required but does not yet exist
 Cm::ast::Sema::SemaContext::result_t
 Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >
 Cm::SmallBitset::reverse_iterator
 Cm::pe::hs::heuristics::scaled_sum< PlanTable, State, Expand >
 Cm::pe::hs::heuristics::scaled_sum< PlanTable, State, BottomUp >
 Cm::SchedulerThe Scheduler handles the execution of all incoming queries
 Cm::SchemaA Schema represents a sequence of identifiers, optionally with a prefix, and their associated types
 Cm::wasm::Scope
 Cm::pe::hs::search_states::EdgePtrBottomUp::Scratchpad
 Cm::ai::SearchConfiguration< StaticConfig >Relies on the rules of aggregate initialization
 Cm::ast::Sema::SemaContextHolds context information used by semantic analysis of a single statement
 CLinearizedDP::Sequence
 Cstd::shared_ptr< T >STL class
 Cskewed_distribution< RealType >A distribution of values in range [0; 1] that are skewed towards 0
 Cm::SmallBitsetImplements a small and efficient set over integers in the range of 0 to 63 (including)
 Cm::some< T >A helper type to wrap some template type parameter such that it can safely be used to declare a class field or local variable
 Cm::some< void >
 Cm::sorted_vector< T, Compare >A sorted list of elements
 Cm::gs::Space< T, Derived >
 Cm::gs::Space< T, LinearSpace >
 Cm::SpnTree structure for Sum Product Networks
 Cm::SpnEstimatorSpnEstimator that estimates cardinalities based on Sum-Product Networks
 Cm::SpnWrapperA wrapper class for an Spn to be used in the context of databases
 Cm::pe::hs::heuristics::sqrt_sum< PlanTable, State, Expand >
 Cm::pe::hs::heuristics::sqrt_sum< PlanTable, State, TopDown >
 Cm::StackMachineA stack machine that evaluates an expression
 Cm::pe::hs::search_states::Base< Actual >::state_counters_t
 Cm::ai::StateManager< State, Expand, Heurisitc, HasRegularQueue, HasBeamQueue, Config, Context >Tracks states and their presence in queues
 Cm::ai::StateManager< State, Expand, Heuristic, not(use_beam_search and is_monotone), use_beam_search, StaticConfig, Context... >
 Cm::detail::stl_visit_helper< Callable, ResultType, Visitor, Class, Classes >This helper class creates a single override of operator() for one subtype in a class hierarchy, and then recursively inherits from an instantiation of that same helper class for the next subtype in the hierarchy
 Cm::StoreDefines a generic store interface
 Cm::StoreWriterThis class provides direct write access to the contents of a Store
 Cm::StrClone
 Cstd::streambuf
 Cm::StrEqualCompares two cstrings for equality
 Cm::StrEqualWithNullCompares two cstrings for equality
 Cm::StrHashComputes the FNV-1a 64-bit hash of a cstring
 Cm::StringView
 Cm::SubproblemHash
 Cm::SubqueryInfoCollects info of a subquery, i.e
 Cm::SubsetEnumeratorThis class efficiently enumerates all subsets of a given size
 Cm::pe::hs::heuristics::sum< PlanTable, State, Expand >This heuristic estimates the distance from a state to the nearest goal state as the sum of the sizes of all Subproblems yet to be joined
 Cm::pe::hs::heuristics::sum< PlanTable, State, BottomUp >
 Cm::pe::hs::heuristics::sum< PlanTable, State, TopDown >
 Cm::TableA table is a sorted set of attributes
 Cm::TableFactoryThe table factory creates Tables with all enabled decorators
 Cm::tag< Ts >
 Cm::RefCountingHashMap< Key, Value, Hash, KeyEqual >::the_bucket_iterator< C >
 Cm::wasm::HashTable::the_entry< IsConst >Helper struct as proxy to access a hash table entry
 Cm::Block< N >::the_iterator< C >
 Cm::doubly_linked_list< T, Allocator >::the_iterator< C >
 Cm::pe::hs::search_states::EdgePtrBottomUp::the_iterator< IsConst >
 Cm::pe::hs::search_states::SubproblemTableBottomUp::the_iterator< IsConst >
 Cm::RefCountingHashMap< Key, Value, Hash, KeyEqual >::the_iterator< C >
 Cm::Table::the_iterator< V, H >
 Cm::wasm::detail::the_reference< T, L, IsConst >
 Cm::wasm::HashTable::the_reference< T, IsConst >Helper struct as proxy to access a single value (inclusive NULL bit) of a hash table entry
 Cm::wasm::HashTable::the_reference< NChar, IsConst >
 Cm::TimerCollect timings of events
 Cm::Timer::TimingProcessA proxy class to record a Measurement with a Timer
 Cm::ast::Token
 Cm::pe::hs::expansions::TopDown
 Cm::Scheduler::Transaction
 Cstd::true_type
 Cm::Tuple
 Cstd::tuple
 Cm::TypeThis class represents types in the SQL type system
 Cm::detail::typed_param_pack_helper< P, T >Helper struct to check whether parameter pack type
 Cm::wasm::uint< W >Helper type to deduce the unsigned integral type with a given byte width
 Cm::wasm::uint< 1 >
 Cm::wasm::uint< 2 >
 Cm::wasm::uint< 4 >
 Cm::wasm::uint< 8 >
 Cv8_inspector::V8InspectorClient
 Cm::ValueThis class holds a SQL attribute value
 Cm::wasm::detail::var_helper< T >Deduces a suitable specialization of Variable for the given type
 Cm::wasm::detail::var_helper< Expr< T, L > >
 Cm::wasm::detail::var_helper< PrimitiveExpr< T, L > >
 Cm::wasm::Variable< typename, VariableKind, bool, size_t >
 Cm::wasm::Variable< T, Kind, CanBeNull, L >
 Cm::wasm::Variable< T, VariableKind::Param, false, L >
 Cm::wasm::detail::variable_storage< typename, VariableKind, bool, size_t >
 Cm::wasm::detail::variable_storage< T, Kind, CanBeNull, L >
 Cstd::vector< T >STL class
 Cm::version::version_info
 Cm::view< It, Fn >
 Cm::view< It, ReturnType &(It)>
 Cm::visit_skip_subtreeException class which can be thrown to skip recursion of the subtree in pre-order visitors
 Cm::visit_stop_recursionException class which can be thrown to stop entire recursion in visitors
 Cm::detail::visitor_method_helper< ConcreteVisitor, Base, Class, Classes >This helper class creates a single definition of virtual void operator()(...) for one subtype in a class hierarchy, and then recursively inherits from an instantiation of that same helper class for the next subtype in the hierarchy
 Cm::detail::visitor_method_helper< ConcreteVisitor, Base, Hierarchy... >
 Cm::wasm::detail::wasm_type_helper< typename, size_t >Converts a compile-time type into a runtime-type ::wasm::Type
 Cm::wasm::detail::wasm_type_helper< PrimitiveExpr< T, L >, 1 >Specialization for
 Cm::wasm::detail::wasm_type_helper< ReturnType(ParamTypes...), 1 >Specialization for
 Cm::wasm::detail::wasm_type_helper< T, 1 >Specialization for
 Cm::wasm::detail::wasm_type_helper< T, L >Specialization for
 Cm::WasmEngine::WasmContextA WasmContext holds associated information of a WebAssembly module instance
 Cm::WasmEngineA WasmEngine provides an environment to compile and execute WebAssembly modules
 Cm::WasmModuleA WasmModule is a wrapper around a [Binaryen] (https://github.com/WebAssembly/binaryen) wasm::Module
 Cm::WebSocketServer
 CWeighExpr
 Cm::pe::hs::config::weighted_search< B >
 Cm::wasm::While
 Cm::write_lock
 Cm::pe::hs::heuristics::zero< PlanTable, State, Expand >
 CAllocator
 Cconditional_t< Ordered, std::vector< std::pair< Schema::Identifier, Order > >, std::unordered_map< Schema::Identifier, Order, IdentifierHash > >
 Centry_type
 Cfriend
 CT
 Cm::Ts