►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 Backend s |
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 Database s 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 ConditionSet s 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 QueryExpr s 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 ConditionSet s 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 Table s, Function s, 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 DataLayout s for a given sequence of Type s, 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::Identifier s 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 DataSource s 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 Tuple s 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 Subproblem s 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 DatabaseCommand s 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 Subproblem s 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 Table s 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 | PrimitiveType s represent Type s 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::Clause s |
Cm::cnf::Clause | A cnf::Clause represents a disjunction of Predicate s |
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 > | |