Data Structures

Here are the data structures with brief descriptions:

[detail level 123456]

►Nm	‍mutable namespace
►Nai
Cbudget_exhausted_exception
CgenericAStar	Implements a generic A* search algorithm
CSearchConfiguration	Relies on the rules of aggregate initialization
►CStateManager	Tracks states and their presence in queues
Ccomparator	‍comparator for map entries based on states' g + h value
CPartitions
CPartitions< false >
CPartitions< true >
►Nast
CASTDot	Implements printing the AST in dot language
CASTDumper	Dumps a textual representation of the AST to an output stream
CASTPrinter	Pretty-prints the AST in SQL
CASTVisitor
CBinaryExpr	A binary expression
CCheckConditionConstraint
CClause
CCommand
CConstant	A constant: a string literal or a numeric constant
CConstASTVisitor
CConstraint	Abstract class to represent constraints attached to attributes of a table
CCreateDatabaseStmt
CCreateIndexStmt
►CCreateTableStmt
Cattribute_definition
CDeleteStmt	A SQL delete statement
CDesignator	A designator
CDropDatabaseStmt
CDropIndexStmt
CDropTableStmt
CDSVImportStmt	An import statement for a delimiter separated values (DSV) file
CEmptyStmt
CErrorClause
CErrorExpr	The error expression
CErrorStmt	The error statement
CExpr	An expression
CFnApplicationExpr	A function application
►CFromClause
Cfrom_type
CGroupByClause
CHavingClause
CImportStmt	A SQL import statement
CInsertStmt	A SQL insert statement
CInstruction
CLexer
CLimitClause
CNotNullConstraint
COrderByClause
CParser
CPostfixExpr	A postfix expression
CPrimaryKeyConstraint
CQueryExpr	A query expression for nested queries
CReferenceConstraint
CSelectClause
CSelectStmt	A SQL select statement
►CSema
CRequireContext	Helper class to create a context when one is required but does not yet exist
►CSemaContext	Holds context information used by semantic analysis of a single statement
Cresult_t
CStmt	A SQL statement
CThePostOrderExprVisitor
CThePreOrderExprVisitor
CTheRecursiveExprVisitorBase	A generic base class for implementing recursive ast::Expr visitors
CToken
CUnaryExpr	A unary expression: "+e", "-e", "~e", "NOT e"
CUniqueConstraint
CUpdateStmt	A SQL update statement
CUseDatabaseStmt
CWhereClause
►Ncnf
CClause	A cnf::Clause represents a disjunction of Predicates
CCNF	A CNF represents a conjunction of cnf::Clauses
CPredicate	A Predicate contains a Expr of Boolean type in either positive or negative form
►Ndetail
C_StringPool	Explicit specialization of PODPool for strings (const char *)
Cas_tuple	Static cast of
Cas_tuple< param_pack_t< Ts... > >	Specialization for
CConcretePhysicalPlanTableIterator
Ccondition_entry_t	Helper struct to unite ConditionSets and entries of type
Cis_param_pack	Checks whether
Cis_param_pack< param_pack_t< Ts... > >	Specialization for
Cis_specialization
Cis_specialization< Template< Args... >, Template >
Creader_writer_mutex_internal	NOTE: This class is not thread-safe
Cstl_visit_helper	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
Cstl_visit_helper< Callable, ResultType, Visitor, Class >	This specialization marks the end of the class hierarchy
Cthe_condition_entry_iterator	Iterator interface to iterate over pairs of ConditionSet and
Cthe_condition_entry_templated_iterator	Helper struct for templated iterators
Ctyped_param_pack_helper	Helper struct to check whether parameter pack type
CVisitor	Visitor base class, using CRTP
Cvisitor_method_helper	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
Cvisitor_method_helper< ConcreteVisitor, Base, Class >	This specialization marks the end of the class hierarchy
CVisitorImpl	A helper class to define virtual visit methods for all classes in
►Ngs
CGridSearch
CLinearSpace
CSpace
►Nidx
CArrayIndex	A simple index based on a sorted array that maps keys to their tuple_id
CIndexBase	The base class for indexes
►CRecursiveModelIndex	A recursive model index with two layers consiting only of linear monels that maps keys to their tuple_id
CLinearModel
►Ninterpreter
CMatchBase	An abstract MatchBase for the Interpreter backend
CThePostOrderMatchBaseVisitor
CThePreOrderMatchBaseVisitor
CTheRecursiveMatchBaseVisitorBase	A generic base class for implementing recursive interpreter::MatchBase visitors
►NM_OPERATOR_LIST
CThePostOrderOperatorVisitor
CThePreOrderOperatorVisitor
►Nmemory
CAddressSpace	This class represents a reserved address space in virtual memory
CAllocator	This is the common interface for all memory allocators that support rewiring
CLinearAllocator	This is the simplest kind of allocator
CMemory	Represents a mapping created by a memory::Allocator
►Npe	‍plan enumerator namespace
►Nhs	‍heuristic search namespace
►Nconfig
Canytime_search
Cbeam
Ccombine	Combines multiple configuration parameters into a single configuration type
Ccombine< T >	Combines multiple configuration parameters into a single configuration type
Ccost_based_pruning
CFibonacci_heap
Clazy
Cmonotone
Cweighted_search
►Nexpansions	‍heuristic search state expansions namespace
CBottomUp
CBottomUpComplete
CTopDown
CTopDownComplete
►Nheuristics
Cavg_sel
Cavg_sel< PlanTable, State, BottomUp >
Cbottomup_lookahead_cheapest
CGOO	Inspired by GOO: Greedy Operator Ordering
CGOO< PlanTable, State, BottomUp >
CGOO< PlanTable, State, TopDown >	Inspired by GOO: Greedy Operator Ordering
Cproduct	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
Cproduct< PlanTable, State, BottomUp >
Cscaled_sum
Cscaled_sum< PlanTable, State, BottomUp >
Csqrt_sum
Csqrt_sum< PlanTable, State, TopDown >
Csum	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
Csum< PlanTable, State, BottomUp >
Csum< PlanTable, State, TopDown >
Czero
►Nsearch_states	‍heuristic search states namespace
►CBase	A state in the search space
Cstate_counters_t
►CEdgePtrBottomUp
CScratchpad
Cthe_iterator
CEdgesBottomUp
CSubproblemsArray
►CSubproblemTableBottomUp
Cthe_iterator
CHeuristicSearch	Computes the join order using heuristic search
CDPccp	Computes the join order using connected subgraph complement pairs (CCP)
Cenumerate_tag
►CGOO	Greedy operator ordering
Cnode
CPlanEnumerator	An interface for all plan enumerators
CPlanEnumeratorCRTP
CTDGOO	Top-down version of greedy operator ordering
►Nstorage
►CDataLayout	Models how data is laid out in a linear address space
►CINode	An internal node of the recursive data layout model
Cchild_t	‍a child Node and its relative offset and stride within the containing INode
Cconst_iterator
CLeaf	The Leaf represents exactly one attribue
Cleaf_info_t	‍combines information of a single leaf for for_sibling_leaves()
Clevel_info_t	‍combines information of a single internal level inside the DataLayout, used by for_sibling_leaves()
CNode	‍an abstract node in the recursive data layout model
CDataLayoutFactory	This is an interface for factories that compute particular DataLayouts for a given sequence of Types, e.g
CPAXLayoutFactory
CRowLayoutFactory
►Nterm
CColor	Wrapper class to ease the use of terminal colors (foreground and background)
►Nversion
Cversion_info
►Nwasm
►Ndetail
C_var_helper	Deduces a suitable specialization of Variable that can be NULL for the given type
C_var_helper< Expr< T, L > >
C_var_helper< PrimitiveExpr< T, L > >
Cglobal_helper	Deduces a suitable specialization of Variable for global variables of the given type
Cglobal_helper< PrimitiveExpr< T, L > >
Clocal_bit_storage	Helper class to select appropriate storage for a LocalBit
Clocal_bit_storage< 1 >	Specialization for a single bit
Cptr_helper
Cptr_helper< PrimitiveExpr< T, L > >
Cptr_helper< void >
Cthe_reference
CV8InspectorClientImpl
Cvar_helper	Deduces a suitable specialization of Variable for the given type
Cvar_helper< Expr< T, L > >
Cvar_helper< PrimitiveExpr< T, L > >
Cvariable_storage
Cwasm_type_helper	Converts a compile-time type into a runtime-type ::wasm::Type
Cwasm_type_helper< PrimitiveExpr< T, L >, 1 >	Specialization for
Cwasm_type_helper< ReturnType(ParamTypes...), 1 >	Specialization for
Cwasm_type_helper< T, 1 >	Specialization for
Cwasm_type_helper< T, L >	Specialization for
CWebSocketChannel
C_int	Helper type to deduce the signed integral type with a given byte width
C_int< 1 >
C_int< 2 >
C_int< 4 >
C_int< 8 >
CAggregation
CAllocator
CBit
CBlock	Represents a code block, i.e
CBlockUser	A helper class to use a Block, thereby setting the Block active for code generation
Cbranch_target_t	Stores the "branch targets" introduced by control flow structures, i.e
CBuffer	Buffers tuples by materializing them into memory
Cbuffer_load_proxy_t	Proxy to implement loads from a buffer
Cbuffer_storage
Cbuffer_storage< false >
Cbuffer_storage< true >
Cbuffer_store_proxy_t	Proxy to implement stores to a buffer
Cbuffer_swap_proxy_t	Proxy to implement swaps in a buffer
CCallback
Cchained_hash_table_storage
Cchained_hash_table_storage< false >
Cchained_hash_table_storage< true >
CChainedHashTable
CCodeGenContext	The Wasm CodeGenContext provides context information necessary for code generation
CConstantFolding	Helper struct to perform constant folding at compile time
CDecimal
CDoWhile
CEnvironment	Binds Schema::Identifiers to Expr<T>s
Cexception
CExpr
Cexpr	Helper type to deduce the Expr<U> type given a
Cexpr< detail::the_reference< T, L, IsConst > >	Specialization for
Cexpr< Expr< T, L > >	Specialization for
Cexpr< Parameter< T, L > >	Specialization for
Cexpr< PrimitiveExpr< T, L > >	Specialization for
Cexpr< T >	Specialization for decayable
CExpr< 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)
Cexpr< Variable< T, Kind, CanBeNull, L > >	Specialization for
CExprCompiler	Compiles AST expressions m::Expr to Wasm ASTs m::wasm::Expr<T>
CFilter
CFunction	Represents a Wasm function
CFunction< void(PrimitiveExpr< ParamTypes, ParamLs >...)>
CFunctionProxy	A handle to create a Function and to create invocations of that function
CFunctionProxy< void(PrimitiveExpr< ParamTypes, ParamLs >...)>
CGarbageCollectedData	Helper struct for garbage collection done by the Module
CHashBasedGrouping
CHashBasedGroupJoin
►CHashTable	Hash table to hash key-value pairs in memory
Cthe_entry	Helper struct as proxy to access a hash table entry
Cthe_reference	Helper struct as proxy to access a single value (inclusive NULL bit) of a hash table entry
Cthe_reference< NChar, IsConst >
CIf
CIndexScan
Cinvoke_interpreter
Cinvoke_v8
Cis_sql_addr_type
Cis_sql_type
CLazyDisjunctiveFilter
CLimit
CLinearProbing	Linear probing strategy, i.e
CLocalBit
CLocalBitmap
CLocalBitvector
CLoop	Implements a loop which iterates exactly once unless explicitly continue-ed
CMatchBase	An abstract MatchBase for the WasmV8 backend
CMatchLeaf	Intermediate match type for leaves, i.e
CMatchMultipleChildren	Intermediate match type for physical operator matches with multiple children
CMatchSingleChild	Intermediate match type for physical operator matches with a single child
CModule
CNChar
CNestedLoopsJoin
CNoOp
CNoOpSorting
Copen_addressing_hash_table_layout
Copen_addressing_hash_table_layout< false >
Copen_addressing_hash_table_layout< true >
Copen_addressing_hash_table_storage
Copen_addressing_hash_table_storage< false >
Copen_addressing_hash_table_storage< true >
COpenAddressingHashTable
►COpenAddressingHashTableBase
CProbingStrategy	Probing strategy to handle collisions in an open addressing hash table
COrderedGrouping
CParameter
CParameter< T, L >	A type to access function parameters
Cprimitive_expr	Helper type to deduce the PrimitiveExpr<U> type given a type
Cprimitive_expr< detail::the_reference< T, L, IsConst > >	Specialization for
Cprimitive_expr< Parameter< T, L > >	Specialization for
Cprimitive_expr< PrimitiveExpr< T, L > >	Specialization for
Cprimitive_expr< T >	Specialization for decayable
Cprimitive_expr< Variable< T, Kind, false, L > >	Specialization for
CPrimitiveExpr
CPrint
Cprint_types	A helper type to print Wasm types
Cprint_types< param_pack_t< T >, L >	Prints the Wasm type for
Cprint_types< param_pack_t< T, Ts... >, L, Ls... >	Prints the Wasm type for
CProjection
CQuadraticProbing	Quadratic probing strategy, i.e
CQuicksort
CScan
CScope
CSimpleHashJoin
CSortMergeJoin
CThePostOrderMatchBaseVisitor
CThePreOrderMatchBaseVisitor
CTheRecursiveMatchBaseVisitorBase	A generic base class for implementing recursive wasm::MatchBase visitors
Cuint	Helper type to deduce the unsigned integral type with a given byte width
Cuint< 1 >
Cuint< 2 >
Cuint< 4 >
Cuint< 8 >
CVariable
CVariable< T, Kind, CanBeNull, L >
CWhile
►C__virtual_crtp_helper	A helper class to introduce a virtual method overload per type to a class hierarchy
►Creturns
►Ccrtp_args
►Cargs
Cbase_type_helper
Cbase_type_helper< false, T >
Cbase_type_helper< true, T >
Cderived_type_helper
Cderived_type_helper< false, Actual, T >
Cderived_type_helper< true, Actual, T >
►CAdjacencyMatrix	An adjacency matrix for a given query graph
CProxy	A proxy to access single entries in the AdjacencyMatrix
CAggregationOperator
Callocator
►CArgParser	A parser for command line arguments
COption
COptionImpl
CAttribute	An attribute of a table
CBackend	Defines the interface of all execution Backends
Cbackend_exception
CBaseTable	A BaseTable is a DataSource that is materialized and stored persistently by the database system
CBitmap	The bitmap type
►CBlock	A block of size N contains N tuples
Cthe_iterator
CBoolean	The boolean type
Ccalculate_filter_cost_tag
Ccalculate_grouping_cost_tag
Ccalculate_join_cost_tag
CCallbackOperator
►CCardinalityEstimator
Cdata_model_exception	data_model_exception is thrown if a DataModel implementation does not contain the requested information
►CCartesianProductEstimator	DummyEstimator that always returns the size of the cartesian product of the given subproblems
CCartesianProductDataModel
CCatalog	The catalog contains all Databases and keeps track of all meta information of the database system
CCharacterSequence	The type of character strings, both fixed length and varying length
CClauseInfo	Collects information of a cnf::Clause
CColumnStore	This class implements a column store
Ccommon_type	Computes the common type of
Ccommon_type< T, T >	Specialization for equal types
Ccommon_type< T, U >	If both
CConcat
CConcat< std::variant< Args0... >, Args1... >
CConcreteCondition2PPTEntryMap
CConcretePhysicalPlanTable
CConcretePhysicalPlanTableEntry
CConcreteTable	Basic implementation of Table
CConcreteTableFactory	Basic implementation of TableFactory
CConcreteTableFactoryDecorator
CCondition
CCondition2PPTEntryMap	Interface for a mapping between ConditionSets and physical plan table entries of type
Cconditional_one
Cconditional_one< false, TrueType, FalseType >
►CConditionPropertyMap
CIdentifierHash
CConditionSet
CConsumer	A Consumer is an Operator that can be evaluated on a sequence of tuples
CCostFunction
CCostFunctionCout	Implements the cassical, widely used cost function C_out from Sophie Cluet and Guido Moerkotte
CCostFunctionCRTP
CCostModelFactory
CCreateDatabase
CCreateIndex
CCreateTable
Ccrtp	A helper class to define CRTP class hierarchies
Ccrtp_boolean	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)
Ccrtp_boolean_templated	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)
►CDatabase	A Database is a set of Tables, Functions, and Statistics
Cindex_entry_type
CDatabaseCommand	The command pattern for operations in the DBMS
CDatabaseInstruction	A DatabaseInstruction represents an invokation of an instruction with (optional) arguments
CDataModel	A DataModel describes a data set
CDataSource	A DataSource in a QueryGraph
CDate	The date type
CDateTime	The date type
CDDLCommand
CDeleteRecords	Delete records from a Table of a Database
CDiagnostic
CDisjunctiveFilterOperator
CDMLCommand	Base class for all commands resulting from a data manipulation language (DML) statement
CDotTool	This class enables direct rendering of dot output (e.g
►Cdoubly_linked_list	Implements a doubly-linked list with an overhead of just a single pointer per element
Cnode_type
Cthe_iterator
CDropDatabase
CDropIndex
CDropTable
►CDSVReader	A reader for delimiter separated value (DSV) files
CConfig	Configuration parameters for importing a DSV file
Cdyn_array	Implements an array of dynamic but fixed size
CEmptyCommand
CErrorType	This Type is assigned when parsing of a data type fails or when semantic analysis detects a type error
Cestimate_join_all_tag
Cexception
CFilterOperator
CFnType	The function type defines the type and count of the arguments and the type of the return value of a SQL function
Cfrontend_exception
CFunction	Defines a function
Cget_nodes
Cget_nodes< pattern_t< Op, Children... > >
Cget_singleton_operator
Cget_singleton_operator< Op >
Cget_singleton_operator< pattern_t< Op, Wildcard > >
Cget_singleton_operator< pattern_t< Op, Wildcard, Wildcard > >
Cget_tm
CGospersHack	Enumerate all subsets of size k based on superset of size n
CGraphBuilder
CGroupingOperator
Chas_producer_root
Chas_producer_root< Op >
Chas_producer_root< pattern_t< Op, Children... > >
CImportDSV	Import records from a delimiter separated values (DSV) file into a Table of a Database
►CInjectionCardinalityEstimator	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
CInjectionCardinalityDataModel
CInsertRecords	Insert records into a Table of a Database
CInterpreter	Evaluates SQL operator trees on the database
Cinvalid_argument	Signals that an argument to a function of method was invalid
Cinvalid_state	Signals that an object was in an invalid state when a method was invoked
Cis_pattern
Cis_pattern< pattern_t< Ts... > >
Cis_singleton_pattern
Cis_singleton_pattern< Op >
Cis_singleton_pattern< pattern_t< Op, Wildcard > >
Cis_singleton_pattern< pattern_t< Op, Wildcard, Wildcard > >
Cis_streamable
Cis_streamable< S, T, std::void_t< decltype(std::declval< S & >()<< std::declval< T >())> >
CJoin	A Join in a QueryGraph combines DataSources by a join condition
CJoinOperator
Clazy_construct
Clearn_spns	Learn an SPN on every table in the database that is currently in use
►CLimitOperator
Cstack_unwind
CLinearModel	A model for predicting the costs of a physical operator
Clist_allocator	Implements a list allocator
Clogic_error	Base class for exceptions signaling an error in the logic
Cmalloc_allocator	This allocator serves allocations using malloc/free
CMatch
CMatch< wasm::Aggregation >
CMatch< wasm::Callback< SIMDfied > >
CMatch< wasm::Filter< Predicated > >
CMatch< wasm::HashBasedGrouping >
CMatch< wasm::HashBasedGroupJoin >
CMatch< wasm::IndexScan< IndexMethod > >
CMatch< wasm::LazyDisjunctiveFilter >
CMatch< wasm::Limit >
CMatch< wasm::NestedLoopsJoin< Predicated > >
CMatch< wasm::NoOp >
CMatch< wasm::NoOpSorting >
CMatch< wasm::OrderedGrouping >
CMatch< wasm::Print< SIMDfied > >
CMatch< wasm::Projection >
CMatch< wasm::Quicksort< CmpPredicated > >
CMatch< wasm::Scan< SIMDfied > >
CMatch< wasm::SimpleHashJoin< UniqueBuild, Predicated > >
CMatch< wasm::SortMergeJoin< SortLeft, SortRight, Predicated, CmpPredicated > >
CMatchBase
CMinCutAGaT
CMultiVersioningTable	A multi-versioning table is a Table with additional invisible timestamp attributes
CNoneType	A Type that represents the absence of any other type
CNoOpOperator	Drops the produced results and outputs only the number of result tuples produced
CNoSIMD
CNumeric	The numeric type represents integer and floating-point types of different precision and scale
COperator	An Operator represents an operation in a query plan
COperatorData	This interface allows for attaching arbitrary data to Operator instances
COperatorInformation	This class provides additional information about an Operator, e.g
COptField
COptField< false, T >
COptimizer	The optimizer interface
COptions	Singleton class representing options provided as command line argument to the binaries
Cout_of_range	Signals that an index-based or key-based access was out of range
Coverloaded
CPairHash	Computes the XOR-hash for a pair
Cparam_pack_t	Helper struct for parameter packs
CPartialPlanGenerator	A partial plan is a set of (potentially incomplete) pairwise disjoint plans
Cpartition_predicated_naive	Partitions the range begin to end (exclusive) into two partitions using pivot
Cpattern_matcher_base	Abstract base class of all matchable patterns
Cpattern_matcher_impl
Cpattern_matcher_recursive
Cpattern_matcher_recursive< PhysOp, Idx, Op, PatternQueue... >
Cpattern_matcher_recursive< PhysOp, Idx, pattern_t< Op, Children... >, PatternQueue... >
Cpattern_t
Cpattern_validator
Cpattern_validator< Op >
CPaxStore	This class implements a generic PAX store
CPhysicalOperator
CPhysicalOptimizer	The physical optimizer interface
CPhysicalOptimizerImpl	Concrete PhysicalOptimizer implementation using a concrete statically-typed
CPhysicalPlanTable	Interface for an entire physical plan table containing a ConditionSet-entry-mapping
CPhysicalPlanTableEntry	Interface for a single physical plan table entry
CPipeline	Implements push-based evaluation of a pipeline in the plan
CPlanTableBase
CPlanTableDecorator
CPlanTableEntry
CPlanTableEntryData	This interface allows for attaching arbitrary data to PlanTableEntry instances
CPlanTableLargeAndSparse	This table represents all explored plans with their sub-plans, estimated size, cost, and further optional properties
CPlanTableSmallOrDense	This table represents all explored plans with their sub-plans, estimated size, cost, and further optional properties
CPODPool	The PODPool implements an implicitly garbage-collected set of pooled (or internalized) POD struct entities
►CPool	A pool implements an implicitly garbage-collected set of instances of a class hierarchy
Cdereference_equal_to
Cdereference_hash
CPooled	A data type representing a pooled (or internalized) object
CPosition
CPredicated
CPrimitiveType	PrimitiveTypes represent Types of values
CPrintOperator	Prints the produced Tuples to a std::ostream instance
CProducer	A Producer is an Operator that can be evaluated to a sequence of tuples
Cprojecting_iterator
Cprojecting_iterator< It, ReturnType &(It), OwnsProjection >
CProjectionOperator
Cput_timepoint
Cput_tm
CQuery	A Query in a QueryGraph is a DataSource that represents a nested query
CQueryDatabase	Run a query against the selected database
CQueryGraph	The query graph represents all data sources and joins in a graph structure
CQueryGraph2SQL	Translates a query graph in SQL
Crange
Cread_lock
CReader	An interface for all readers
Creader_writer_lock	This is a helper class that helps managing reader and writer locks claimed from reader_writer_mutex
Creader_writer_mutex	Implements a many-readers, single-writer locking concept
►CRefCountingHashMap
Centry_type
Cthe_bucket_iterator
Cthe_iterator
CRowStore	This class implements a row store
Cruntime_error	Signals a runtime error that mu*t*able is not responsible for and that mu*t*able was not able to recover from
CScanOperator
►CScheduler	The Scheduler handles the execution of all incoming queries
CTransaction
►CSchema	A Schema represents a sequence of identifiers, optionally with a prefix, and their associated types
Centry_type
CIdentifier	An Identifier is composed of a name and an optional prefix
►CSerialScheduler	This class implements a Scheduler that executes all incoming DatabaseCommands serially
CCommandQueue	A thread-safe query plan queue
Csetup_t
CSIMD
►CSmallBitset	Implements a small and efficient set over integers in the range of 0 to 63 (including)
Citerator
CProxy	A proxy to access single elements in SmallBitset
Creverse_iterator
Csome	A helper type to wrap some template type parameter such that it can safely be used to declare a class field or local variable
Csome< void >
Csorted_vector	A sorted list of elements
CSortedness
CSortingOperator
►CSpn	Tree structure for Sum Product Networks
►CContinuousLeaf
CBin
►CDiscreteLeaf
CBin
CLearningData
CNode
►CProduct
CChildWithVariables
►CSum
CChildWithWeight
►CSpnEstimator	SpnEstimator that estimates cardinalities based on Sum-Product Networks
CSpnDataModel
CSpnWrapper	A wrapper class for an Spn to be used in the context of databases
CSQLCommand
CStackMachine	A stack machine that evaluates an expression
CStackMachineBuilder
CStore	Defines a generic store interface
CStoreWriter	This class provides direct write access to the contents of a Store
CStrClone
CStrEqual	Compares two cstrings for equality
CStrEqualWithNull	Compares two cstrings for equality
CStrHash	Computes the FNV-1a 64-bit hash of a cstring
CStringView
CSubproblemHash
CSubqueryInfo	Collects info of a subquery, i.e
CSubsetEnumerator	This class efficiently enumerates all subsets of a given size
►CTable	A table is a sorted set of attributes
Cthe_iterator
CTableDecorator	Abstract Decorator class that concrete TableDecorator inherit from
CTableFactory	The table factory creates Tables with all enabled decorators
CTableFactoryDecorator	Abstract Decorator class that concrete TableFactoryDecorator inherit from
Ctag
Cteardown_t
►CTimer	Collect timings of events
CMeasurement
CTimingProcess	A proxy class to record a Measurement with a Timer
CTrainedCostFunction
CTuple
CType	This class represents types in the SQL type system
CUnsatisfiable
Cunsharable_shared_ptr	This class extends std::shared_ptr to allow for unsharing an exclusively held object and thereby converting to a std::unique_ptr
CUpdateRecords	Modify records of a Table of a Database
Cupgrade_lock
CUseDatabase
CValue	This class holds a SQL attribute value
Cview
Cview< It, ReturnType &(It)>
Cvisit_skip_subtree	Exception class which can be thrown to skip recursion of the subtree in pre-order visitors
Cvisit_stop_recursion	Exception class which can be thrown to stop entire recursion in visitors
CWasmBackend	A Backend to execute a plan on a specific WasmEngine
►CWasmEngine	A WasmEngine provides an environment to compile and execute WebAssembly modules
CWasmContext	A WasmContext holds associated information of a WebAssembly module instance
CWasmModule	A WasmModule is a wrapper around a [Binaryen] (https://github.com/WebAssembly/binaryen) wasm::Module
►CWebSocketServer
CConnection
Cwrite_lock
►Nstd	STL namespace
►Nstd
Chash< m::Pooled< T, Pool, CanBeNone > >
Chash< Container >
Chash< m::ast::Expr >	Specialization of std::hash to m::ast::Expr
Chash< m::Attribute >	Specializes std::hash<T> for m::Attribute
Chash< m::cnf::Predicate >
Chash< m::pe::hs::search_states::EdgePtrBottomUp >
Chash< m::pe::hs::search_states::EdgesBottomUp >
Chash< m::pe::hs::search_states::SubproblemsArray >
Chash< m::pe::hs::search_states::SubproblemTableBottomUp >
Chash< m::Schema::Identifier >	Specializes std::hash<T> for m::Schema::Identifier
Chash< m::Tuple >
Chash< m::Type >
Chash< m::Value >
Chash< std::reference_wrapper< T > >	Convenience specialization to provide hashing of std::reference_wrapper by hashing the referenced object
Caggregate_info_t	‍helper struct for aggregates
Cargs_t
CASTClauseVisitor
CASTCommandVisitor
CASTConstraintVisitor
CASTExprVisitor
Cavg_aggregate_info_t	‍helper struct for AVG aggregates
CCNFGenerator	Helper class to convert Expr and Clause to cnf::CNF
CConstASTClauseVisitor
CConstASTCommandVisitor
CConstASTConstraintVisitor
CConstASTExprVisitor
CConstOperatorVisitor
CConstPostOrderOperatorVisitor
CConstTypeVisitor
CDPsize	Computes the join order using size-based dynamic programming
CDPsizeOpt	Computes the join order using size-based dynamic programming
CDPsizeSub	Computes the join order using size-based dynamic programming
CDPsub	Computes the join order using subset-based dynamic programming
CDPsubOpt	Computes the join order using subset-based dynamic programming
CGetNestedQueries	Helper structure to extract the QueryExprs in an expression
CIKKBZ	Implements join ordering using the IK/KBZ algorithm
Cindex_scan_bounds_t	‍helper struct holding the bounds for index scan
CLinearAllocator	A simple linear allocator which keeps a global pointer to the next free memory address and advances it for allocation
►CLinearizedDP
CSequence
CMockInterface
CNullBuffer
CNullStream
CPEall	Computes the join order by enumerating all join orders, including Cartesian products
Cprint_info
CPtr
Cskewed_distribution	A distribution of values in range [0; 1] that are skewed towards 0
CTDbasic
CTDMinCutAGaT
CWeighExpr