| ►Cconst_virtual_crtp_helper:: returns:: crtp_args:: args | |
| Cm::calculate_filter_cost_tag | |
| ►Cconst_virtual_crtp_helper:: returns:: crtp_args:: args | |
| Cm::calculate_grouping_cost_tag | |
| ►Cconst_virtual_crtp_helper:: returns:: crtp_args:: args | |
| Cm::calculate_join_cost_tag | |
| ►Cconst_virtual_crtp_helper:: returns:: crtp_args:: args | |
| Cm::pe::enumerate_tag | |
| ►Cconst_virtual_crtp_helper:: returns:: crtp_args:: args | |
| Cm::estimate_join_all_tag | |
| 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::AddressSpace | This class represents a reserved address space in virtual memory |
| Cm::AdjacencyMatrix | An adjacency matrix for a given query graph |
| Caggregate_info_t |
helper struct for aggregates
|
| Cm::allocator< Actual > | |
| ►Cm::memory::Allocator | This is the common interface for all memory allocators that support rewiring |
| Cm::memory::LinearAllocator | This is the simplest kind of allocator |
| ►Cm::wasm::Allocator | |
| CLinearAllocator | A simple linear allocator which keeps a global pointer to the next free memory address and advances it for allocation |
| ►Cm::allocator< list_allocator > | |
| Cm::list_allocator | Implements a list allocator |
| ►Cm::allocator< malloc_allocator > | |
| Cm::malloc_allocator | This allocator serves allocations using malloc/free |
| Cm::pe::hs::config::anytime_search< B > | |
| Cm::ArgParser | A 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 | |
| ►Cm::ast::ASTVisitor | |
| Cm::ast::Sema | |
| ►CASTCommandVisitor | |
| Cm::ast::ASTVisitor | |
| ►CASTConstraintVisitor | |
| Cm::ast::ASTVisitor | |
| ►CASTExprVisitor | |
| Cm::ast::ASTVisitor | |
| Cm::Attribute | An 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::Backend | Defines the interface of all execution Backends |
| Cm::Interpreter | Evaluates SQL operator trees on the database |
| Cm::WasmBackend | A Backend to execute a plan on a specific WasmEngine |
| ►Ccalculate_filter_cost_tag::base_type | |
| ►Cm::CostFunction | |
| ►Cm::CostFunctionCRTP< CostFunctionCout > | |
| Cm::CostFunctionCout | Implements the cassical, widely used cost function C_out from Sophie Cluet and Guido Moerkotte |
| ►Cm::CostFunctionCRTP< TrainedCostFunction > | |
| Cm::TrainedCostFunction | |
| Cm::CostFunctionCRTP< Actual > | |
| ►Ccalculate_grouping_cost_tag::base_type | |
| Cm::CostFunction | |
| ►Ccalculate_join_cost_tag::base_type | |
| Cm::CostFunction | |
| ►Cenumerate_tag::base_type | |
| ►Cm::pe::PlanEnumerator | An interface for all plan enumerators |
| ►Cm::pe::PlanEnumeratorCRTP< DPsize > | |
| CDPsize | Computes the join order using size-based dynamic programming |
| ►Cm::pe::PlanEnumeratorCRTP< DPsizeOpt > | |
| CDPsizeOpt | Computes the join order using size-based dynamic programming |
| ►Cm::pe::PlanEnumeratorCRTP< DPsizeSub > | |
| CDPsizeSub | Computes the join order using size-based dynamic programming |
| ►Cm::pe::PlanEnumeratorCRTP< DPsub > | |
| CDPsub | Computes the join order using subset-based dynamic programming |
| ►Cm::pe::PlanEnumeratorCRTP< DPsubOpt > | |
| CDPsubOpt | Computes the join order using subset-based dynamic programming |
| ►Cm::pe::PlanEnumeratorCRTP< IKKBZ > | |
| CIKKBZ | Implements join ordering using the IK/KBZ algorithm |
| ►Cm::pe::PlanEnumeratorCRTP< LinearizedDP > | |
| CLinearizedDP | |
| ►Cm::pe::PlanEnumeratorCRTP< PEall > | |
| CPEall | Computes the join order by enumerating all join orders, including Cartesian products |
| ►Cm::pe::PlanEnumeratorCRTP< TDMinCutAGaT > | |
| CTDMinCutAGaT | |
| ►Cm::pe::PlanEnumeratorCRTP< TDbasic > | |
| CTDbasic | |
| ►Cm::pe::PlanEnumeratorCRTP< DPccp > | |
| Cm::pe::DPccp | Computes the join order using connected subgraph complement pairs (CCP) |
| ►Cm::pe::PlanEnumeratorCRTP< GOO > | |
| Cm::pe::GOO | Greedy operator ordering |
| ►Cm::pe::PlanEnumeratorCRTP< TDGOO > | |
| Cm::pe::TDGOO | Top-down version of greedy operator ordering |
| ►Cm::pe::PlanEnumeratorCRTP< HeuristicSearch > | |
| Cm::pe::hs::HeuristicSearch | Computes the join order using heuristic search |
| Cm::pe::PlanEnumeratorCRTP< Actual > | |
| ►Cestimate_join_all_tag::base_type | |
| Cm::CardinalityEstimator | |
| 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 >::derived_type_helper< false, Actual, T > | |
| ►Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::base_type_helper< true, T > | |
| Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::derived_type_helper< true, Actual, 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::Block | Represents a code block, i.e |
| Cm::Block< 64 > | |
| Cm::wasm::BlockUser | A helper class to use a Block, thereby setting the Block active for code generation |
| ►Cm::pe::hs::expansions::BottomUp | |
| Cm::pe::hs::expansions::BottomUpComplete | |
| Cm::pe::hs::heuristics::bottomup_lookahead_cheapest< PlanTable, State > | |
| Cm::wasm::branch_target_t | Stores 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::CartesianProductEstimator | DummyEstimator that always returns the size of the cartesian product of the given subproblems |
| Cm::Catalog | The 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::wasm::detail::WebSocketChannel | |
| 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::ast::ErrorClause | |
| Cm::ast::FromClause | |
| Cm::ast::GroupByClause | |
| Cm::ast::HavingClause | |
| Cm::ast::LimitClause | |
| Cm::ast::OrderByClause | |
| Cm::ast::SelectClause | |
| Cm::ast::WhereClause | |
| Cm::ClauseInfo | Collects information of a cnf::Clause |
| Cm::wasm::CodeGenContext | The Wasm CodeGenContext provides context information necessary for code generation |
| Cm::term::Color | Wrapper class to ease the use of terminal colors (foreground and background) |
| ►Cm::ast::Command | |
| Cm::ast::Instruction | |
| ►Cm::ast::Stmt | A SQL statement |
| Cm::ast::CreateDatabaseStmt | |
| Cm::ast::CreateIndexStmt | |
| Cm::ast::CreateTableStmt | |
| Cm::ast::DeleteStmt | A SQL delete statement |
| Cm::ast::DropDatabaseStmt | |
| Cm::ast::DropIndexStmt | |
| Cm::ast::DropTableStmt | |
| Cm::ast::EmptyStmt | |
| Cm::ast::ErrorStmt | The error statement |
| ►Cm::ast::ImportStmt | A SQL import statement |
| Cm::ast::DSVImportStmt | An import statement for a delimiter separated values (DSV) file |
| Cm::ast::InsertStmt | A SQL insert statement |
| Cm::ast::SelectStmt | A SQL select statement |
| Cm::ast::UpdateStmt | A SQL update statement |
| Cm::ast::UseDatabaseStmt | |
| Cm::SerialScheduler::CommandQueue | A 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::Predicated | |
| ►Cm::SIMD | |
| Cm::NoSIMD | |
| Cm::Sortedness | |
| Cm::Unsatisfiable | |
| 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::M_OPERATOR_LIST::ThePostOrderOperatorVisitor< C > | |
| Cm::M_OPERATOR_LIST::ThePreOrderOperatorVisitor< C > | |
| Cm::ast::ThePostOrderExprVisitor< C > | |
| Cm::ast::ThePreOrderExprVisitor< C > | |
| Cm::ast::TheRecursiveExprVisitorBase< C > | A generic base class for implementing recursive ast::Expr visitors |
| Cm::interpreter::ThePostOrderMatchBaseVisitor< C > | |
| Cm::interpreter::ThePreOrderMatchBaseVisitor< C > | |
| Cm::interpreter::TheRecursiveMatchBaseVisitorBase< C > | A generic base class for implementing recursive interpreter::MatchBase visitors |
| Cm::wasm::ThePostOrderMatchBaseVisitor< C > | |
| Cm::wasm::ThePreOrderMatchBaseVisitor< C > | |
| Cm::wasm::TheRecursiveMatchBaseVisitorBase< C > | A generic base class for implementing recursive wasm::MatchBase visitors |
| Cm::ConditionPropertyMap< Property, Ordered > | |
| Cm::ConditionPropertyMap< Order > | |
| Cm::ConditionSet | |
| Cm::DSVReader::Config | Configuration parameters for importing a DSV file |
| Cm::WebSocketServer::Connection | |
| Cm::storage::DataLayout::INode::const_iterator | |
| Cm::wasm::ConstantFolding | Helper struct to perform constant folding at compile time |
| ►CConstASTClauseVisitor | |
| ►Cm::ast::ConstASTVisitor | |
| Cm::ast::ASTDot | Implements printing the AST in dot language |
| Cm::ast::ASTDumper | Dumps a textual representation of the AST to an output stream |
| Cm::ast::ASTPrinter | Pretty-prints the AST in SQL |
| ►Cast::ConstASTCommandVisitor | |
| Cm::GraphBuilder | |
| ►CConstASTCommandVisitor | |
| Cm::ast::ConstASTVisitor | |
| ►CConstASTConstraintVisitor | |
| Cm::ast::ConstASTVisitor | |
| ►Cast::ConstASTExprVisitor | |
| CGetNestedQueries | Helper structure to extract the QueryExprs in an expression |
| Cm::QueryGraph2SQL | Translates a query graph in SQL |
| Cm::StackMachineBuilder | |
| Cm::wasm::ExprCompiler | Compiles AST expressions m::Expr to Wasm ASTs m::wasm::Expr<T> |
| ►CConstASTExprVisitor | |
| CCNFGenerator | Helper class to convert Expr and Clause to cnf::CNF |
| Cm::ast::ConstASTVisitor | |
| ►CConstOperatorVisitor | |
| Cm::Interpreter | Evaluates SQL operator trees on the database |
| Cm::Pipeline | Implements push-based evaluation of a pipeline in the plan |
| ►CConstPostOrderOperatorVisitor | |
| Cm::PhysicalOptimizerImpl< PhysicalPlanTable > | Concrete PhysicalOptimizer implementation using a concrete statically-typed |
| ►Cm::ast::Constraint | Abstract class to represent constraints attached to attributes of a table |
| Cm::ast::CheckConditionConstraint | |
| Cm::ast::NotNullConstraint | |
| Cm::ast::PrimaryKeyConstraint | |
| Cm::ast::ReferenceConstraint | |
| Cm::ast::UniqueConstraint | |
| ►CConstTypeVisitor | |
| Cm::DSVReader | A reader for delimiter separated value (DSV) files |
| Cm::pe::hs::config::cost_based_pruning< B > | |
| Cm::CostModelFactory | |
| ►Cm::crtp< ConcreteType, CRTPBaseType, TParams > | A helper class to define CRTP class hierarchies |
| ►Cm::PhysicalPlanTable< ConcretePhysicalPlanTable, ConcreteCondition2PPTEntryMap > | |
| Cm::ConcretePhysicalPlanTable | |
| ►Cm::PlanTableBase< PlanTableLargeAndSparse > | |
| Cm::PlanTableLargeAndSparse | This table represents all explored plans with their sub-plans, estimated size, cost, and further optional properties |
| ►Cm::PlanTableBase< PlanTableSmallOrDense > | |
| Cm::PlanTableSmallOrDense | This table represents all explored plans with their sub-plans, estimated size, cost, and further optional properties |
| ►Cm::pe::hs::search_states::Base< EdgePtrBottomUp > | |
| Cm::pe::hs::search_states::EdgePtrBottomUp | |
| ►Cm::pe::hs::search_states::Base< EdgesBottomUp > | |
| Cm::pe::hs::search_states::EdgesBottomUp | |
| ►Cm::pe::hs::search_states::Base< SubproblemTableBottomUp > | |
| Cm::pe::hs::search_states::SubproblemTableBottomUp | |
| ►Cm::pe::hs::search_states::Base< SubproblemsArray > | |
| Cm::pe::hs::search_states::SubproblemsArray | |
| ►Cm::crtp< Actual, Base > | |
| Cm::pe::hs::search_states::Base< Actual > | A state in the search space |
| ►Cm::crtp< Actual, PhysicalOperator, Pattern > | |
| Cm::PhysicalOperator | |
| ►Cm::crtp< Actual, PhysicalPlanTable, Condition2EntryMap > | |
| Cm::PhysicalPlanTable< Actual, Condition2EntryMap > | Interface for an entire physical plan table containing a ConditionSet-entry-mapping |
| ►Cm::crtp< Actual, PlanTableBase > | |
| Cm::PlanTableBase< Actual > | |
| Cm::crtp< ConcretePhysicalPlanTable, PhysicalPlanTable, ConcreteCondition2PPTEntryMap > | |
| ►Cm::crtp< ConcreteVisitor, Visitor, Base > | |
| ►Cm::detail::Visitor< ConcreteVisitor, Base > | Visitor base class, using CRTP |
| Cm::detail::stl_visit_helper< Callable, ResultType, Visitor, Class > | This specialization marks the end of the class hierarchy |
| Cm::detail::visitor_method_helper< ConcreteVisitor, Base, Class > | This specialization marks the end of the class hierarchy |
| 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::detail::the_condition_entry_iterator< ConcretePhysicalPlanTableIterator< Ref, C >, C, ConcretePhysicalPlanTableEntry > | |
| Cm::detail::ConcretePhysicalPlanTableIterator< Ref, C > | |
| ►Cm::detail::the_condition_entry_iterator< Actual< C >, C, Entry > | |
| Cm::detail::the_condition_entry_templated_iterator< Actual, C, Entry > | Helper struct for templated iterators |
| ►Cm::crtp_boolean< Actual, the_condition_entry_iterator, C, Entry > | |
| Cm::detail::the_condition_entry_iterator< Actual, C, Entry > | Iterator interface to iterate over pairs of ConditionSet and |
| 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::Condition2PPTEntryMap< ConcreteCondition2PPTEntryMap, detail::Condition2PPTEntryMapIterator, ConcretePhysicalPlanTableEntry > | |
| Cm::ConcreteCondition2PPTEntryMap | |
| ►Cm::PhysicalPlanTableEntry< ConcretePhysicalPlanTableEntry, detail::PhysicalPlanTableEntryChildIterator > | |
| Cm::ConcretePhysicalPlanTableEntry | |
| ►Cm::crtp_boolean_templated< Actual, Condition2PPTEntryMap, It, Entry > | |
| Cm::Condition2PPTEntryMap< Actual, It, Entry > | Interface for a mapping between ConditionSets and physical plan table entries of type |
| ►Cm::crtp_boolean_templated< Actual, PhysicalPlanTableEntry, ChildIt > | |
| Cm::PhysicalPlanTableEntry< Actual, ChildIt > | Interface for a single physical plan table entry |
| Cm::crtp_boolean_templated< ConcreteCondition2PPTEntryMap, Condition2PPTEntryMap, detail::Condition2PPTEntryMapIterator, ConcretePhysicalPlanTableEntry > | |
| Cm::crtp_boolean_templated< ConcretePhysicalPlanTableEntry, PhysicalPlanTableEntry, detail::PhysicalPlanTableEntryChildIterator > | |
| Cm::Database | A Database is a set of Tables, Functions, and Statistics |
| ►Cm::DatabaseCommand | The command pattern for operations in the DBMS |
| ►Cm::DatabaseInstruction | A DatabaseInstruction represents an invokation of an instruction with (optional) arguments |
| Cm::learn_spns | Learn an SPN on every table in the database that is currently in use |
| Cm::EmptyCommand | |
| ►Cm::SQLCommand | |
| ►Cm::DDLCommand | |
| Cm::CreateDatabase | |
| Cm::CreateIndex | |
| Cm::CreateTable | |
| Cm::DropDatabase | |
| Cm::DropIndex | |
| Cm::DropTable | |
| Cm::UseDatabase | |
| ►Cm::DMLCommand | Base class for all commands resulting from a data manipulation language (DML) statement |
| Cm::DeleteRecords | Delete records from a Table of a Database |
| Cm::ImportDSV | Import records from a delimiter separated values (DSV) file into a Table of a Database |
| Cm::InsertRecords | Insert records into a Table of a Database |
| Cm::QueryDatabase | Run a query against the selected database |
| Cm::UpdateRecords | Modify records of a Table of a Database |
| Cm::storage::DataLayout | Models how data is laid out in a linear address space |
| ►Cm::storage::DataLayoutFactory | This is an interface for factories that compute particular DataLayouts for a given sequence of Types, e.g |
| Cm::storage::PAXLayoutFactory | |
| Cm::storage::RowLayoutFactory | |
| ►Cm::DataModel | A DataModel describes a data set |
| Cm::CartesianProductEstimator::CartesianProductDataModel | |
| Cm::InjectionCardinalityEstimator::InjectionCardinalityDataModel | |
| Cm::SpnEstimator::SpnDataModel | |
| ►Cm::DataSource | A DataSource in a QueryGraph |
| Cm::BaseTable | A BaseTable is a DataSource that is materialized and stored persistently by the database system |
| Cm::Query | A Query in a QueryGraph is a DataSource that represents a nested query |
| Cm::Pool< T, Hash, KeyEqual, ThreadSafe >::dereference_equal_to | |
| Cm::Pool< T, Hash, KeyEqual, ThreadSafe >::dereference_hash | |
| ►Ccalculate_filter_cost_tag::derived_type | |
| Cm::CostFunctionCRTP< CostFunctionCout > | |
| Cm::CostFunctionCRTP< TrainedCostFunction > | |
| Cm::CostFunctionCRTP< Actual > | |
| ►Ccalculate_grouping_cost_tag::derived_type | |
| Cm::CostFunctionCRTP< CostFunctionCout > | |
| Cm::CostFunctionCRTP< TrainedCostFunction > | |
| Cm::CostFunctionCRTP< Actual > | |
| ►Ccalculate_join_cost_tag::derived_type | |
| Cm::CostFunctionCRTP< CostFunctionCout > | |
| Cm::CostFunctionCRTP< TrainedCostFunction > | |
| Cm::CostFunctionCRTP< Actual > | |
| ►Cenumerate_tag::derived_type | |
| Cm::pe::PlanEnumeratorCRTP< DPsize > | |
| Cm::pe::PlanEnumeratorCRTP< DPsizeOpt > | |
| Cm::pe::PlanEnumeratorCRTP< DPsizeSub > | |
| Cm::pe::PlanEnumeratorCRTP< DPsub > | |
| Cm::pe::PlanEnumeratorCRTP< DPsubOpt > | |
| Cm::pe::PlanEnumeratorCRTP< IKKBZ > | |
| Cm::pe::PlanEnumeratorCRTP< LinearizedDP > | |
| Cm::pe::PlanEnumeratorCRTP< PEall > | |
| Cm::pe::PlanEnumeratorCRTP< TDMinCutAGaT > | |
| Cm::pe::PlanEnumeratorCRTP< TDbasic > | |
| Cm::pe::PlanEnumeratorCRTP< DPccp > | |
| Cm::pe::PlanEnumeratorCRTP< GOO > | |
| Cm::pe::PlanEnumeratorCRTP< TDGOO > | |
| Cm::pe::PlanEnumeratorCRTP< HeuristicSearch > | |
| Cm::pe::PlanEnumeratorCRTP< Actual > | |
| Cm::__virtual_crtp_helper< Tag, Const >::returns< ReturnType >::crtp_args< CRTPArgs >::args< Args >::derived_type_helper< C, Actual, T, Ts > | |
| Cm::Diagnostic | |
| Cm::DotTool | This 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::Environment | Binds Schema::Identifiers to Expr<T>s |
| ►Cstd::exception | STL class |
| Cm::LimitOperator::stack_unwind | |
| ►Cm::exception | |
| Cm::CardinalityEstimator::data_model_exception | data_model_exception is thrown if a DataModel implementation does not contain the requested information |
| Cm::ai::budget_exhausted_exception | |
| ►Cm::backend_exception | |
| Cm::wasm::exception | |
| Cm::frontend_exception | |
| ►Cm::logic_error | Base class for exceptions signaling an error in the logic |
| Cm::invalid_argument | Signals that an argument to a function of method was invalid |
| Cm::invalid_state | Signals that an object was in an invalid state when a method was invoked |
| Cm::out_of_range | Signals that an index-based or key-based access was out of range |
| Cm::runtime_error | Signals a runtime error that mu*t*able is not responsible for and that mu*t*able was not able to recover from |
| ►Cm::ast::Expr | An expression |
| Cm::ast::BinaryExpr | A binary expression |
| Cm::ast::Constant | A constant: a string literal or a numeric constant |
| Cm::ast::Designator | A designator |
| Cm::ast::ErrorExpr | The error expression |
| ►Cm::ast::PostfixExpr | A postfix expression |
| Cm::ast::FnApplicationExpr | A function application |
| Cm::ast::QueryExpr | A query expression for nested queries |
| Cm::ast::UnaryExpr | A unary expression: "+e", "-e", "~e", "NOT e" |
| 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::Decimal< 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 | |
| CMockInterface | |
| ►Cstd::false_type | |
| Cm::detail::is_param_pack< T > | Checks whether |
| Cm::detail::is_specialization< T, Template > | |
| Cm::has_producer_root< typename > | |
| Cm::is_pattern< typename > | |
| Cm::is_singleton_pattern< typename > | |
| Cm::is_streamable< S, T, typename > | |
| Cm::pattern_validator< typename > | |
| Cm::pe::hs::config::Fibonacci_heap | |
| Cm::ast::FromClause::from_type | |
| Cm::Function | Defines a function |
| Cm::wasm::Function< typename > | Represents a Wasm function |
| ►Cstd::function | |
| Cm::setup_t | |
| Cm::teardown_t | |
| ►Cm::wasm::Function< PrimitiveExpr< void, 1 >(PrimitiveExpr< ParamTypes, ParamLs >...)> | |
| Cm::wasm::Function< void(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::FunctionProxy< void(PrimitiveExpr< ParamTypes, ParamLs >...)> | |
| Cm::wasm::GarbageCollectedData | Helper 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, Expand > | Inspired by GOO: Greedy Operator Ordering |
| Cm::pe::hs::heuristics::GOO< PlanTable, State, TopDown > | Inspired by GOO: Greedy Operator Ordering |
| Cm::GospersHack | Enumerate 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::HashTable | Hash table to hash key-value pairs in memory |
| Cm::wasm::ChainedHashTable< IsGlobal > | |
| ►Cm::wasm::OpenAddressingHashTableBase | |
| Cm::wasm::OpenAddressingHashTable< IsGlobal, ValueInPlace > | |
| Cm::Schema::Identifier | An 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::IndexBase | The base class for indexes |
| ►Cm::idx::ArrayIndex< Key > | A simple index based on a sorted array that maps keys to their tuple_id |
| Cm::idx::RecursiveModelIndex< Key > | A recursive model index with two layers consiting only of linear monels that maps keys to their tuple_id |
| Cm::InjectionCardinalityEstimator | InjectionCardinalityEstimator 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_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::ostream | STL class |
| CNullStream | |
| Cm::wasm::is_sql_addr_type< typename > | |
| Cm::wasm::is_sql_type< typename > | |
| Cm::SmallBitset::iterator | |
| Cm::Join | A 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::LinearModel | A 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::Loop | Implements a loop which iterates exactly once unless explicitly continue-ed |
| Cm::wasm::DoWhile | |
| Cm::Match< T > | |
| ►Cm::MatchBase | |
| Cm::interpreter::MatchBase | An abstract MatchBase for the Interpreter backend |
| ►Cm::wasm::MatchBase | An abstract MatchBase for the WasmV8 backend |
| Cm::Match< wasm::Projection > | |
| ►Cm::wasm::MatchLeaf | Intermediate match type for leaves, i.e |
| Cm::Match< wasm::IndexScan< IndexMethod > > | |
| Cm::Match< wasm::Scan< SIMDfied > > | |
| ►Cm::wasm::MatchMultipleChildren | Intermediate match type for physical operator matches with multiple children |
| Cm::Match< wasm::HashBasedGroupJoin > | |
| Cm::Match< wasm::NestedLoopsJoin< Predicated > > | |
| Cm::Match< wasm::SimpleHashJoin< UniqueBuild, Predicated > > | |
| Cm::Match< wasm::SortMergeJoin< SortLeft, SortRight, Predicated, CmpPredicated > > | |
| ►Cm::wasm::MatchSingleChild | Intermediate match type for physical operator matches with a single child |
| Cm::Match< wasm::Aggregation > | |
| Cm::Match< wasm::Callback< SIMDfied > > | |
| Cm::Match< wasm::Filter< Predicated > > | |
| Cm::Match< wasm::HashBasedGrouping > | |
| Cm::Match< wasm::LazyDisjunctiveFilter > | |
| Cm::Match< wasm::Limit > | |
| Cm::Match< wasm::NoOp > | |
| Cm::Match< wasm::NoOpSorting > | |
| Cm::Match< wasm::OrderedGrouping > | |
| Cm::Match< wasm::Print< SIMDfied > > | |
| Cm::Match< wasm::Quicksort< CmpPredicated > > | |
| Cm::Timer::Measurement | |
| Cm::memory::Memory | Represents 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::Spn::ContinuousLeaf | |
| Cm::Spn::DiscreteLeaf | |
| Cm::Spn::Product | |
| Cm::Spn::Sum | |
| ►Cm::storage::DataLayout::Node |
an abstract node in the recursive data layout model
|
| Cm::storage::DataLayout::INode | An internal node of the recursive data layout model |
| Cm::storage::DataLayout::Leaf | The Leaf represents exactly one attribue |
| 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::Operator | An Operator represents an operation in a query plan |
| ►Cm::Consumer | A Consumer is an Operator that can be evaluated on a sequence of tuples |
| Cm::AggregationOperator | |
| Cm::CallbackOperator | |
| ►Cm::FilterOperator | |
| Cm::DisjunctiveFilterOperator | |
| Cm::GroupingOperator | |
| Cm::JoinOperator | |
| Cm::LimitOperator | |
| Cm::NoOpOperator | Drops the produced results and outputs only the number of result tuples produced |
| Cm::PrintOperator | Prints the produced Tuples to a std::ostream instance |
| Cm::ProjectionOperator | |
| Cm::SortingOperator | |
| ►Cm::Producer | A Producer is an Operator that can be evaluated to a sequence of tuples |
| Cm::AggregationOperator | |
| Cm::FilterOperator | |
| Cm::GroupingOperator | |
| Cm::JoinOperator | |
| Cm::LimitOperator | |
| Cm::ProjectionOperator | |
| Cm::ScanOperator | |
| Cm::SortingOperator | |
| Cm::OperatorData | This interface allows for attaching arbitrary data to Operator instances |
| Cm::OperatorInformation | This 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::Optimizer | The optimizer interface |
| ►Cm::ArgParser::Option | |
| Cm::ArgParser::OptionImpl< T > | |
| Cm::Options | Singleton 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::PartialPlanGenerator | A partial plan is a set of (potentially incomplete) pairwise disjoint plans |
| Cm::partition_predicated_naive | Partitions 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_base | Abstract base class of all matchable patterns |
| Cm::pattern_matcher_impl< PhysOp, PhysOpt > | |
| 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::wasm::Aggregation | |
| ►Cm::PhysicalOperator< Callback< SIMDfied >, CallbackOperator > | |
| Cm::wasm::Callback< SIMDfied > | |
| ►Cm::PhysicalOperator< Filter< Predicated >, FilterOperator > | |
| Cm::wasm::Filter< Predicated > | |
| ►Cm::PhysicalOperator< HashBasedGrouping, GroupingOperator > | |
| Cm::wasm::HashBasedGrouping | |
| ►Cm::PhysicalOperator< HashBasedGroupJoin, pattern_t< GroupingOperator, pattern_t< JoinOperator, Wildcard, Wildcard > > > | |
| Cm::wasm::HashBasedGroupJoin | |
| ►Cm::PhysicalOperator< IndexScan< IndexMethod >, pattern_t< FilterOperator, ScanOperator > > | |
| Cm::wasm::IndexScan< IndexMethod > | |
| ►Cm::PhysicalOperator< LazyDisjunctiveFilter, DisjunctiveFilterOperator > | |
| Cm::wasm::LazyDisjunctiveFilter | |
| ►Cm::PhysicalOperator< Limit, LimitOperator > | |
| Cm::wasm::Limit | |
| ►Cm::PhysicalOperator< NestedLoopsJoin< Predicated >, JoinOperator > | |
| Cm::wasm::NestedLoopsJoin< Predicated > | |
| ►Cm::PhysicalOperator< NoOp, NoOpOperator > | |
| Cm::wasm::NoOp | |
| ►Cm::PhysicalOperator< NoOpSorting, SortingOperator > | |
| Cm::wasm::NoOpSorting | |
| ►Cm::PhysicalOperator< OrderedGrouping, GroupingOperator > | |
| Cm::wasm::OrderedGrouping | |
| ►Cm::PhysicalOperator< Print< SIMDfied >, PrintOperator > | |
| Cm::wasm::Print< SIMDfied > | |
| ►Cm::PhysicalOperator< Projection, ProjectionOperator > | |
| Cm::wasm::Projection | |
| ►Cm::PhysicalOperator< Quicksort< CmpPredicated >, SortingOperator > | |
| Cm::wasm::Quicksort< CmpPredicated > | |
| ►Cm::PhysicalOperator< Scan< SIMDfied >, ScanOperator > | |
| Cm::wasm::Scan< SIMDfied > | |
| ►Cm::PhysicalOperator< SimpleHashJoin< UniqueBuild, Predicated >, pattern_t< JoinOperator, Wildcard, Wildcard > > | |
| Cm::wasm::SimpleHashJoin< UniqueBuild, Predicated > | |
| ►Cm::PhysicalOperator< SortMergeJoin< SortLeft, SortRight, Predicated, CmpPredicated >, pattern_t< JoinOperator, Wildcard, Wildcard > > | |
| Cm::wasm::SortMergeJoin< SortLeft, SortRight, Predicated, CmpPredicated > | |
| ►Cm::PhysicalOptimizer | The physical optimizer interface |
| Cm::PhysicalOptimizerImpl< PhysicalPlanTable > | Concrete PhysicalOptimizer implementation using a concrete statically-typed |
| Cm::PlanTableDecorator< Actual > | |
| Cm::PlanTableEntry | |
| Cm::PlanTableEntryData | This 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::detail::_StringPool< ThreadSafe > | Explicit specialization of PODPool for strings (const char *) |
| Cm::PODPool< const char *, StrHash, StrEqual, StrClone, false > | |
| ►Cm::PODPool< const char *, StrHash, StrEqual, StrClone, ThreadSafe > | |
| Cm::detail::_StringPool< false > | |
| Cm::detail::_StringPool< true > | |
| 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::Predicate | A 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::ProbingStrategy | Probing strategy to handle collisions in an open addressing hash table |
| Cm::wasm::LinearProbing | Linear probing strategy, i.e |
| Cm::wasm::QuadraticProbing | Quadratic probing strategy, i.e |
| 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::NChar | |
| 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::QueryGraph | The query graph represents all data sources and joins in a graph structure |
| Cm::range< It > | |
| ►Cm::read_lock | |
| Cm::upgrade_lock | |
| ►Cm::Reader | An interface for all readers |
| Cm::DSVReader | A reader for delimiter separated value (DSV) files |
| Cm::reader_writer_lock | This is a helper class that helps managing reader and writer locks claimed from reader_writer_mutex |
| Cm::reader_writer_mutex | Implements a many-readers, single-writer locking concept |
| Cm::detail::reader_writer_mutex_internal | NOTE: This class is not thread-safe |
| Cm::RefCountingHashMap< Key, Value, Hash, KeyEqual > | |
| Cm::ast::Sema::RequireContext | Helper 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::Scheduler | The Scheduler handles the execution of all incoming queries |
| Cm::SerialScheduler | This class implements a Scheduler that executes all incoming DatabaseCommands serially |
| Cm::Schema | A 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::SemaContext | Holds context information used by semantic analysis of a single statement |
| CLinearizedDP::Sequence | |
| ►Cstd::shared_ptr< T > | STL class |
| Cm::unsharable_shared_ptr< m::MatchBase > | |
| Cm::unsharable_shared_ptr< const m::wasm::MatchBase > | |
| Cm::unsharable_shared_ptr< T > | This class extends std::shared_ptr to allow for unsharing an exclusively held object and thereby converting to a std::unique_ptr |
| Cskewed_distribution< RealType > | A distribution of values in range [0; 1] that are skewed towards 0 |
| Cm::SmallBitset | Implements 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::gs::LinearSpace< T > | |
| Cm::Spn | Tree structure for Sum Product Networks |
| Cm::SpnEstimator | SpnEstimator that estimates cardinalities based on Sum-Product Networks |
| Cm::SpnWrapper | A 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::StackMachine | A 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::Store | Defines a generic store interface |
| Cm::ColumnStore | This class implements a column store |
| Cm::PaxStore | This class implements a generic PAX store |
| Cm::RowStore | This class implements a row store |
| Cm::StoreWriter | This class provides direct write access to the contents of a Store |
| Cm::StrClone | |
| ►Cstd::streambuf | |
| CNullBuffer | |
| Cm::StrEqual | Compares two cstrings for equality |
| Cm::StrEqualWithNull | Compares two cstrings for equality |
| Cm::StrHash | Computes the FNV-1a 64-bit hash of a cstring |
| Cm::StringView | |
| Cm::SubproblemHash | |
| Cm::SubqueryInfo | Collects info of a subquery, i.e |
| Cm::SubsetEnumerator | This 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::Table | A table is a sorted set of attributes |
| Cm::ConcreteTable | Basic implementation of Table |
| ►Cm::TableDecorator | Abstract Decorator class that concrete TableDecorator inherit from |
| Cm::MultiVersioningTable | A multi-versioning table is a Table with additional invisible timestamp attributes |
| ►Cm::TableFactory | The table factory creates Tables with all enabled decorators |
| Cm::ConcreteTableFactory | Basic implementation of TableFactory |
| ►Cm::TableFactoryDecorator | Abstract Decorator class that concrete TableFactoryDecorator inherit from |
| Cm::ConcreteTableFactoryDecorator< T > | |
| 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::Timer | Collect timings of events |
| Cm::Timer::TimingProcess | A proxy class to record a Measurement with a Timer |
| Cm::ast::Token | |
| ►Cm::pe::hs::expansions::TopDown | |
| Cm::pe::hs::expansions::TopDownComplete | |
| Cm::Scheduler::Transaction | |
| ►Cstd::true_type | |
| Cm::detail::is_param_pack< param_pack_t< Ts... > > | Specialization for |
| Cm::detail::is_specialization< Template< Args... >, Template > | |
| Cm::has_producer_root< Op > | |
| Cm::has_producer_root< pattern_t< Op, Children... > > | |
| Cm::is_pattern< pattern_t< Ts... > > | |
| Cm::is_singleton_pattern< Op > | |
| Cm::is_singleton_pattern< pattern_t< Op, Wildcard > > | |
| Cm::is_singleton_pattern< pattern_t< Op, Wildcard, Wildcard > > | |
| Cm::is_streamable< S, T, std::void_t< decltype(std::declval< S & >()<< std::declval< T >())> > | |
| Cm::pattern_validator< Op > | |
| Cm::Tuple | |
| ►Cstd::tuple | |
| Cm::param_pack_t< Ts > | Helper struct for parameter packs |
| ►Cm::Type | This class represents types in the SQL type system |
| Cm::ErrorType | This Type is assigned when parsing of a data type fails or when semantic analysis detects a type error |
| Cm::FnType | The function type defines the type and count of the arguments and the type of the return value of a SQL function |
| Cm::NoneType | A Type that represents the absence of any other type |
| ►Cm::PrimitiveType | PrimitiveTypes represent Types of values |
| Cm::Bitmap | The bitmap type |
| Cm::Boolean | The boolean type |
| Cm::CharacterSequence | The type of character strings, both fixed length and varying length |
| Cm::Date | The date type |
| Cm::DateTime | The date type |
| Cm::Numeric | The numeric type represents integer and floating-point types of different precision and scale |
| 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::wasm::detail::V8InspectorClientImpl | |
| Cm::Value | This 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::Parameter< T, L > | A type to access function parameters |
| 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::cnf::CNF | A CNF represents a conjunction of cnf::Clauses |
| Cm::cnf::Clause | A cnf::Clause represents a disjunction of Predicates |
| Cm::version::version_info | |
| Cm::view< It, Fn > | |
| Cm::view< It, ReturnType &(It)> | |
| Cm::visit_skip_subtree | Exception class which can be thrown to skip recursion of the subtree in pre-order visitors |
| Cm::visit_stop_recursion | Exception 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::detail::VisitorImpl< ConcreteVisitor, Base, Hierarchy > | A helper class to define virtual visit methods for all classes in |
| 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::WasmContext | A WasmContext holds associated information of a WebAssembly module instance |
| Cm::WasmEngine | A WasmEngine provides an environment to compile and execute WebAssembly modules |
| Cm::WasmModule | A 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::pe::hs::config::combine< T, Ts > | Combines multiple configuration parameters into a single configuration type |
| Cm::pe::hs::config::combine< T > | Combines multiple configuration parameters into a single configuration type |
| ►Cm::Ts | |
| Cm::overloaded< Ts > | |
1.9.6