Fennel: Class List (original) (raw)
Exception class for aborted execution
Abstract base class representing computation of a single aggregate function over a collection of scalar values all having the same group key
AggInvocation represents one call to an aggregate function
AioLinuxScheduler implements DeviceAccessScheduler via Linux-specific kernel-mode libaio calls
AioPollingScheduler implements DeviceAccessScheduler via Unix aio calls and threads which poll for completion
AioSignalScheduler implements DeviceAccessScheduler via Unix aio calls and threads which run a signal handler
AtomicCounter wraps STL support for atomic increment/decrement
AttributeAccessor defines how to efficiently unmarshal the value of an attribute from a stored tuple
AttributeAccessorImpl is a common base for all implementations of the AttributeAccessor interface
AutoBacktrace provides a handler that intercepts fatal errors, prints a backtrace, and passes on the fatal error to other handlers
A Backtrace represents a backtrace of the run-time stack
Random access request binding for I/O requests issued during backup/restore
Unit test for backup and restore of database header pages and a VersionedRandomAllocationSegment
BarrierExecStream is a synchronizing barrier to wait for the completion of several upstream producers and generate a status output for the downstream consumer
BarrierExecStreamParams defines parameters for BarrierExecStream
BernoulliRng produces a series of values with a Bernoulli distribution
BernoulliSamplingExecStream implements TABLESAMPLE BERNOULLI
BernoulliSamplingExecStreamGenerator
Bernoulli sampling data generator
BernoulliSamplingExecStreamParams
BernoulliSamplingExecStreamParams defines parameters for BernoulliSamplingExecStream
BitAccessor accesses NOT NULL bit attributes
Structure containing information about the constructed bitmaps corresponding the inputs and expected result
BoolNativeGreaterEqual< TMPLT >
BoolNativeInstruction< TMPLT >
Support for operators that return booleans, i.e
BoolPointerGreater< PTR_TYPE >
BoolPointerGreaterEqual< PTR_TYPE >
BoolPointerInstruction< PTR_TYPE >
Support for operators that return booleans, i.e
BoolPointerInstructionRegister
BoolPointerIsNotNull< PTR_TYPE >
BoolPointerLessEqual< PTR_TYPE >
BoolPointerNotEqual< PTR_TYPE >
BTreeAccessBase is a base for classes which access BTree contents
BTreeBuilder implements bulk load for BTrees
BTreeBuildLevel is subordinate to BTreeBuilder
BTreeCompactNodeAccessor maintains the data on a BTreeNode as a compact array of fixed-length entries, with all free space contiguous at the end of the page
BTreeDescriptor defines the information required for accessing a BTree
Exception class for duplicate keys encountered during insert or update
BTreeExecStream is a common base for ExecStream implementations which access BTrees
BTreeExecStreamParams defines parameters common to implementations of BTreeExecStream
BTreeHeapNodeAccessor maintains the data on a BTreeNode using a standard indirection scheme
BTreeInsertExecStream inserts tuples into a BTree, reading them from an upstream stream producer
BTreeInserterParams defines parameters for instantiating a BTreeInserter
BTreeKeyedNodeAccessor< NodeAccessor, KeyAccessor >
BTreeKeyedNodeAccessor is a template for implementing some of the virtual methods in the BTreeNodeAccessor interface
BTreeLeafReader extends BTreeReader by only doing reads of leaf pages in a btree
Header stored on each page of a BTree
BTreeNodeAccessor is an abstract base class for accessing the sorted tuple data stored on a BTreeNode
BTreeNonLeafReader extends BTreeReader by only doing reads of non-leaf pages in a btree
BTreeParams defines parameters used when accessing btrees
BTreePrefetchSearchExecStream extends BTreeSearchExecStream by pre-fetching index leaf pages
BTreePrefetchSearchExecStreamParams
BTreePrefetchSearchExecStreamParams defines parameters for instantiating a BTreePrefetchSearchExecStream
Structure used to store the search key information that was used to locate a pre-fetched btree leaf page
BTreeReader provides read-only access to the contents of a BTree
Dummy stack implementation used when we don't care about keeping track of PageId's on the way down
This test unit tests the BTreeNonLeafReader and BTreeLeafReader classes
BTreeReadExecStream is an abstract base class for ExecStream implementations which project a stream of tuples via a BTreeReader
BTreeReadExecStreamParams defines parameters for instantiating a BTreeReadExecStream
BTreeRecoveryFactory implements the LogicalTxnParticipantFactory interface by constructing BTreeWriters to be used for recovery
BTreeScanExecStream reads all data from a BTree
BTreeScanExecStreamParams defines parameters for instantiating a BTreeScanExecStream
BTreeSearchExecStream reads keys from a child and returns matching tuples in the BTree
BTreeSearchExecStreamParams defines parameters for instantiating a BTreeSearchExecStream
Structure used to store information about dynamic parameters used in the btree search
BTreeSearchUniqueExecStream is a specialization of BTreeSearchExecStream for the case where it is known that each search is guaranteed to find at most one match
BTreeSortExecStream sorts its input stream according to a parameterized key and returns the sorted data as its output, using a BTree to accomplish the sort
BTreeSortExecStreamParams defines parameters for instantiating a BTreeSortExecStream
BTreeStatistics is used to return information about the tree computed as a side-effect of verification
BTreeVerifier checks BTree integrity
BTreeWriter extends BTreeReader to provide read-write access to the contents of a BTree
ByteArrayInputStream implements the ByteInputStream interface by reading data from an existing fixed-size array of bytes
ByteArrayOutputStream implements the ByteOutputStream interface by writing data to an existing fixed-size array of bytes
ByteBuffer allows access to an array of buffers as a single memory space
ByteInputStream defines an interface for reading from a stream of bytes
ByteOutputStream defines an interface for writing to a stream of bytes
ByteStream is a common base class for ByteInputStream and ByteOutputStream
ByteStreamMarker is an opaque position within a ByteStream
ByteWindow represents a window into a large array of bytes
Cache defines an abstract interface for caching pages of devices
CacheAccessor defines the subset of the Cache interface used for accessing cache pages
CacheAllocator defines an interface for allocating memory pages to be used by the cache
CacheImpl< PageT, VictimPolicyT >
CacheImpl is a template implementation of the Cache interface
CachePage is a descriptor for the state of a page of cache memory
CacheParams defines parameters used to instantiate a Cache
CacheStats defines performance/activity statistics collected by the cache; these can be obtained as a snapshot from Cache::collectStats()
CacheTest exercises the entire Cache interface in both single-threaded and multi-threaded modes
CacheTestBase is a common base for any test which depends on the Cache interface
The CalcAssembler is responsible for taking a textual representation of a calculator program and forming a calculator
A CalcAssemblerException represents a exception generated by the CalcAssembler while assembling a calculator program
Exception class for errors encountered during calculator execution
CalcExecStream reads tuples from a child stream and performs calculations of SQL expressions
CalcExecStreamParams defines parameters for instantiating a CalcExecStream
CalcExecStreamTestSuite tests the CalcExecStream
CalcLexer is the scanner class used by the assembler to tokenize a calculator program
An object for passing warning and error messages from execution
CalcTokenUnion is an union of the possible basic types that a token/expression can be in the calculator grammar
CalcTokenValue is the data type of the sematic values of the tokens
CalcYYLocType provides the location of the token or expression being parsed
CartesianJoinExecStream produces the Cartesian product of two input streams
CartesianJoinExecStreamParams defines parameters for instantiating a CartesianJoinExecStream
CastCast< RESULT_T, SOURCE_T >
CastInstruction< RESULT_T, SOURCE_T >
Instructions that cast between types
CheckpointProvider defines an interface for requesting a checkpoint
CheckpointThread is dedicated to listening for checkpoint requests and carrying them out
A circular buffer containing a maximum of N entries of type T
Iterator over a circular buffer
CircularSegment implements circular page allocation in terms of an underlying LINEAR_ALLOCATION segment
ClosableObject is a common base for all classes which require a close() method to be called before destruction (e.g
A destructor functor for use as the "D" parameter to a boost::shared_ptr constructor
Information about the cluster page
CmdInterpreter interprets command objects received via JNI from Farrago
Handle type for a database
CmdInterpreter::ExecutionHandle
Handle type for storing execution state information
CmdInterpreter::StreamGraphHandle
Handle type which combines a database with a txn
CollectExecStream reads all tuples from a child stream and collects them into a single tuple which is written to one output tuple
CollectExecStreamParams defines parameters for instantiating a CollectExecStream
Test Suite for the collect/uncollect xo's
Column generator
Generates a result set consisting of columns each generated by its own generator
CompoundId is a collection of static methods for manipulating PageIds, BlockIds, and SegByteIds
ConduitExecStream is an abstract base for any ExecStream with exactly one input and one output
ConduitExecStreamParams defines parameters for ConduitExecStream
ConfigMap defines a simple container for configuration parameter/value pairs
ConfluenceExecStream is an abstract base for any ExecStream with multiple inputs and exactly one output
ConfluenceExecStreamParams defines parameters for ConfluenceExecStream
Constant column generator
CopyExecStream is an adapter for converting the output of a BUFPROV_PRODUCER producer stream for use by a BUFPROF_CONSUMER consumer stream
CopyExecStreamParams defines parameters for CopyExecStream
Mapping an id to an left input column
CorrelationJoinExecStream produces a join of two input streams
CorrelationJoinExecStreamParams
CorrelationJoinExecStreamParams defines parameters for instantiating a CorrelationJoinExecStream
CorrelationJoinExecStreamTestSuite
CountAggComputer is an abstract base for computing COUNT()
CountNullableAggComputer computes COUNT(X), which does not count tuples for which X IS NULL
CountStarAggComputer computes COUNT(*), which counts tuples without regard for null values
CrcSegInputStream extends SegInputStream by verifying checksum information on each page read
CrcSegOutputStream extends SegOutputStream by stamping each page with a CRC/PseudoUuid/PageId combination
Database defines the top-level database object, which is the unit of self-contained storage and recovery
Header stored in the first two pages of a Database data file
Exception class for incompatible data format errors
Visitor interface for dump/check/repair functions
DelegatingCacheAccessor is a common base class for all implementations of CacheAccessor which delegate part of their behavior to another underlying CacheAccessor
DelegatingSegment is a common base class for all Segments which delegate part of their behavior to another underlying Segment
DeviceAccessScheduler is an interface representing the ability to initiate access requests on devices and handle their completions asynchronously
DeviceAccessSchedulerParams defines parameters used to create a DeviceAccessScheduler
DeviceIdPagePredicate is an implementation of PagePredicate which returns true for pages mapped to a given DeviceId
DfsTreeExecStreamScheduler is a reference implementation of the ExecStreamScheduler interface
DiffluenceExecStream is an abstract base for any ExecStream with multiple outputs and exactly one input
DiffluenceExecStreamParams defines parameters for DiffluenceExecStream
DoubleBufferExecStream is an adapter for converting the output of an upstream BUFPROV_CONSUMER producer for use by a downstream BUFPROV_PRODUCER consumer, with support for the producer and consumer executing in parallel
DoubleBufferExecStreamParams defines parameters for DoubleBufferExecStream
Duplicate column generator
DupRepeatingSeqColumnGenerator
A duplicating repeating column sequence generator
DynamicDelegatingSegment is similar to DelegatingSegment, except the delegating segment can be dynamically changed during the life of the segment
Dynamic parameters are parameters (physically tuples) shared amongst streams
DynamicParamExecStreamGenerator
Outputs the value of a specified dynamic param, reinterpreted as int64_t
DynamicParamManager defines methods to allocate, access, and deallocate dynamic parameters
ErrorSource is a common base for all classes that post row exceptions to an ErrorTarget
ErrorTarget defines an interface for receiving Fennel row errors
ExecStream defines an abstract base for all execution objects which process streams of data
ExecStreamBufAccessor defines access to the buffer memory via which ExecStreams transfer data
ExecStreamBuilder builds a prepared ExecStreamGraph from its Java representation
ExecStreamEmbryo encapsulates the "embryonic" state of an ExecStream in which it has been created, and thus has a definite type, and also has all of its parameters defined; but its prepare() method has not yet been called
ExecStreamFactory builds an ExecStreamEmbryo from the Java representation of a stream definition
ExecStreamGovernor defines an abstract base for determining resource allocation for an execution stream graph as well as the individual execution streams within the graph
Testcase for the exec stream resource governor
An ExecStreamGraph is a directed graph representing dataflow among ExecStreams
ExecStreamGraphEmbryo encapsulates the "embryonic" state of an ExecStreamGraph as its constituent embryonic streams are built up
ExecStreamGraphImpl is an implementation for the ExecStreamGraph interface based on the boost graph template
ExecStreamGraphImpl::DotEdgeRenderer
ExecStreamGraphImpl::DotGraphRenderer
ExecStreamGraphImpl::DotVertexRenderer
ExecStreamGraphImpl::DynamicParamInfo
ExecStreamGraphImpl::ExplicitEdgePredicate
ExecStreamHowTo is a guide to writing new implementations of the ExecStream interface and plugging them into Farrago
Common parameters for instantiating any ExecStream
ExecStreamQuantum defines the quantum for scheduling of an ExecStream
ExecStreamResourceKnobs is a structure that stores the settings of the different knobs that are used to determine exec stream resource allocation
ExecStreamResourceQuantity quantifies various resources which can be allocated to an ExecStream
ExecStreamResourceRequirements
Structure used to track the resource requirements for a single stream
ExecStreamScheduler defines an abstract base for controlling the scheduling of execution streams
ExecStreamTestBase is a common base for tests of ExecStream implementations
ExecStreamTestSuite tests various implementations of ExecStream
ExecStreamUnitTestBase extends ExecStreamTestBase to be the common base of the unit tests of ExecStreams which assume a single stream graph
Base class for all extended instructions
Extended instruction which takes 0 parameters and is implemented using a functor
Extended instruction which takes 0 parameters and is implemented using a functor
Extended instruction which takes 1 parameter and is implemented using a functor
ExtendedInstruction1Context< T0 >
Extended instruction which takes 1 parameter and is implemented using a functor
ExtendedInstruction2< T0, T1 >
Extended instruction which takes 2 parameters and is implemented using a functor
ExtendedInstruction2Context< T0, T1 >
Extended instruction which takes 2 parameters and is implemented using a functor
ExtendedInstruction3< T0, T1, T2 >
Extended instruction which takes 3 parameters and is implemented using a functor
ExtendedInstruction3Context< T0, T1, T2 >
Extended instruction which takes 3 parameters and is implemented using a functor
ExtendedInstruction4< T0, T1, T2, T3 >
Extended instruction which takes 4 parameters and is implemented using a functor
ExtendedInstruction4Context< T0, T1, T2, T3 >
Extended instruction which takes 4 parameters and is implemented using a functor
ExtendedInstruction5< T0, T1, T2, T3, T4 >
Extended instruction which takes 5 parameters and is implemented using a functor
ExtendedInstruction5Context< T0, T1, T2, T3, T4 >
Extended instruction which takes 5 parameters and is implemented using a functor
A abstract base class for Extended Instructions that wish to store context between exec() calls
Describes an extended instruction
A singleton mapping of ExtendedInstruction signatures to ExtendedInstruction functors
ExtentAllocationNode is the allocation map for one extent in a RandomAllocationSegment
ExternalSortExecStream sorts its input stream according to a parameterized key and returns the sorted data as its output
ExternalSortExecStreamImpl implements the ExternalSortExecStream interface
ExternalSortExecStreamParams defines parameters for instantiating an ExternalSortExecStream
Data structure used for array fetch when reading from substreams
Global information shared with sorter sub-components
TODO: doc
ExternalSortMerger manages the process of merging stored runs
ExternalSortMerger marshals XO output buffers by fetching from a top-level ExternalSortSubStream
ExternalSortRunAccessor manages I/O for storing runs and reading them back
ExternalSortRunLoader manages the state of a run as it is being loaded and sorted in memory
Fetch interface implemented by sorter subcomponents which return intermediate results
ExternalSortTask represents a task entry in the queue serviced by the parallel sorter's thread pool
ExtremeAggComputer computes MIN/MAX, ignoring null values but returning null if the input is empty
Base class for all Fennel exceptions
FileDevice is a base class for devices built atop the OS file system
FileStatsTarget implements the StatsTarget interface by writing to a simple text file
FileSystem provides some static utility methods for manipulating the OS file system
FixedOffsetVarWidthAccessor< network >
FixedOffsetVarWidthAccessor accesses the first variable-width attribute if it is NOT NULL
FixedWidthAccessor accesses NOT NULL fixed width attributes
FixedWidthNetworkAccessor16 accesses NOT NULL fixed width 16-bit attributes in network byte order
FixedWidthNetworkAccessor32 accesses NOT NULL fixed width 32-bit attributes in network byte order
FixedWidthNetworkAccessor64 accesses NOT NULL fixed width 64-bit attributes in network byte order
FlatFileBuffer provides data for FlatFileExecStream
Describes characteristics of a column to be parsed
Result of scanning for a column in a flat file format buffer
FlatFileExecStream parses a text file and produces tuples according to a specified column format
FlatFileExecStreamImpl implements the FlatFileExecStream interface
FlatFileExecStreamParams defines parameters for instantiating a FlatFileExecStream
This class parses fields and rows from a field delimited text buffer
Describes a vector of columns to be parsed
Result of scanning for a row in a flat file format buffer
FtrsTableWriter performs inserts, updates, and deletes on the indexes making up a table
FtrsTableWriterExecStream reads tuples from a child stream and uses them to write to all of the indexes making up a table (either INSERT or DEELETE depending on prepared parameters)
FtrsTableWriterExecStreamParams
FtrsTableWriterExecStreamParams defines parameters for instantiating a FtrsTableWriterExecStream
FtrsTableWriterFactory implements the LogicalTxnParticipantFactory interface by constructing FtrsTableWriters to be used for recovery
FtrsTableWriterParams defines parameters for instantiating a FtrsTableWriter
FunctorExtendedInstructionDef< T >
Definition of an extended instruction based upon a functor
FuzzyCheckpointSet keeps track of dirty pages at the time of a checkpoint
GroupLock is a synchronization object for enforcing mutual exclusion among an indefinite number of groups with indefinite cardinalities
std::hash< fennel::OpaqueInteger< T, Dummy > >
Structure for passing input data corresponding to bitmap inputs and expected result
Description of an instruction
Dynamically create Instruction objects given an InstructionDescription description of the desired Instruction
Provide a method to register Instruction objects into the Instruction Factory
IntegralNativeInstruction< TMPLT >
IntegralNativeInstruction_NotAnIntegralType< char >
IntegralNativeInstruction_NotAnIntegralType< int >
IntegralNativeInstruction_NotAnIntegralType< long >
IntegralNativeInstruction_NotAnIntegralType< long long >
IntegralNativeInstruction_NotAnIntegralType< short >
IntegralNativeInstruction_NotAnIntegralType< signed char >
IntegralNativeInstruction_NotAnIntegralType< unsigned char >
IntegralNativeInstruction_NotAnIntegralType< unsigned int >
IntegralNativeInstruction_NotAnIntegralType< unsigned long >
IntegralNativeInstruction_NotAnIntegralType< unsigned long long >
IntegralNativeInstruction_NotAnIntegralType< unsigned short >
IntegralNativeInstructionRegister
IntegralNativeShiftLeft< TMPLT >
IntegralNativeShiftRight< TMPLT >
IntegralPointerInstruction< PTR_TYPE >
PointerSizeT is the only valid result type defined for IntegralPointerInstruction
IntegralPointerInstructionRegister
Iterator over an intrusive doubly-linked list
A link in an intrusive doubly-linked list
IntrusiveList< T, DerivedListNode >
IntrusiveList is a singly-linked list which requires its elements to derive from IntrusiveListNode (endowing them with the required forward links)
IntrusiveListIter< T, DerivedListNode >
IntrusiveListIter is the companion iterator for InstrusiveList
IntrusiveListMutator< T, DerivedListNode >
IntrusiveListMutator is the companion mutator for InstrusiveList
See class IntrusiveList for details
IntrusiveTwoDListIter< ElementT, ReturnT >
Iterator over two intrusive doubly-linked lists
Exception class for invalid parameter settings
Exception indicating an invalid type
Exception indicating a type/value mismatch
IoCompletionPortScheduler implements DeviceAccessScheduler via the Win32 IoCompletionPort facility
JavaErrorTarget implements ErrorTarget by calling back into the Farrago error handling facility
Exception class for wrapping Java exceptions
JavaSinkExecStream reads its tuples from an upstream execution object and pumps them into Java
JavaSinkExecStreamParams defines parameters for instantiating a JavaSinkExecStream
JavaThreadTracker implements ThreadTracker by attaching and detaching the Java environment
JavaTraceTarget implements TraceTarget by calling back into the java.util.logging facility
JavaTransformExecStream represents a sequence of Java transforms encapsulated within a Fennel ExecStream
An implementation of JniEnvRef which can be used in contexts where no JNIEnv is available yet
Wrapper for a JNIEnv pointer
Helper for JniEnvRef
Guard for deleting a local ref automatically on unwind
JniProxy is the virtual base class for all generated proxies
JniProxyIter is used to access a JniProxy by reference
JniProxyVisitor is the base for all classes which need to visit one or more instances of JniProxy polymorphically
JniProxyVisitTable implements a template-driven dispatch table for binding proxy types to visit methods
JniProxyVisitTable< Visitor >::VisitorMethodImpl< ProxyImpl >
Functor implementation binding a JniProxy subclass (instantiating ProxyImpl) to a Visitor::visit method
JniProxyVisitTableBase::VisitorMethod
Abstract functor for calling the correct visit method
Static utility methods for dealing with JNI
JniUtilParams defines parameters used to configure JniUtil
LbmBitOpExecStream is a base class for implementing bit operation execution streams that read from N input streams
LbmBitOpExecStreamParams defines parameters for instantiating a LbmBitOpExecStream
This class encapsulates a single byte segment, as opposed to a tuple which contains a set of them
LbmChopperExecStream splits up tuples whose decompressed representations are too large to fit into the memory of associated streams
LbmChopperExecStreamParams defines parameters for instantiating a LbmChopperExecStream
LbmBTreeRidReader is a class for reading RIDs from a deletion index
Class implementing bitmap index entries
Class used to dump the contents of a LbmEntry
Structure that associates a scratch buffer with each bitmap entry under construction
Testcase for LbmEntry class
LbmExecStreamTestBase is the base class for tests of bitmap exec streams
LbmGeneratorExecStream reads the column store clusters corresponding to the columns of an index, and creates bitmap entries for those rows
LbmIntersectExecStream is the execution stream used to perform intersection on two or more bitmap stream inputs
LbmIntersectExecStreamParams defines parameters for instantiating a LbmIntersectExecStream
Testcase for Intersect exec stream
LbmIterableRidReader provides an iterator interface to a rid reader
Testcase for loading multiple clusters
LbmMinusExecStream is the execution stream that subtracts from the first bitmap input stream, the bitmap streams from the remaining inputs
LbmMinusExecStreamParams defines parameters for instantiating a LbmMinusExecStream
Testcase for Minus exec stream
The bitmap normalizer stream expands bitmap data to tuples
This structure defines parameters for instantiating an LbmNormalizerExecStream
Test case for LbmNormalizerExecStream
Combines a NumberStream with other attributes used to make test data
Test for bitmap tuple and rid reader classes
LbmRepeatingAggComputer is an aggregate computer that wraps another aggregate computer
LbmRidReader provides an interface for reading RIDs from an input stream
LbmRidReaderBase provides an interace for reading RIDs from bit segments
LbmSearchExecStream is the execution stream used for scanning bitmap indexes
LbmSearchExecStreamParams defines parameters for instantiating a LbmSearchExecStream
Testcase for scanning a single bitmap index using equality search on all index keys
Class implementing bitmap segments
LbmSegmentReader provides the interace necessary to read bit segments
LbmSegmentReaderBase provides the base class for reading from bitmap segments
LbmSegmentWriter constructs a bitmap segment by utilizing LbmEntry to write out individual byte segments
LbmSeqSegmentReader provides the interace necessary to read byte segments sequentially
LbmSingleTupleReader is a class satisyfing the bitmap tuple reader interface for a single input tuple
LbmSortedAggExecStream aggregates its input, producing tuples with aggregate computations as output
LbmSortedAggExecStreamParams defines parameters for LbmSortedAggExecStream
Test case for LbmSortedAggExecStream
LbmSplicerExecStream takes as input a stream of bitmap entries
Testcase for splicer exec stream
LbmStreamTupleReader is a base class for reading bitmap tuples from an input stream
LbmTupleReader is an interface for reading bitmap tuples
LbmTupleRidReader is a class for reading rids from bitmap tuples
LbmUnionExecStream is the execution stream used to perform a union on a stream of overlapping bitmap tuple
LbmUnionExecStreamParams defines parameters for instantiating a LbmUnionExecStream
The union workspace merges byte segments
Batch directory representing each batch within a cluster
LcsClusterAccessBase is a base for classes which access cluster pages
Given a stream of tuples corresponding to the column values in a cluster, loads the cluster pages
LcsClusterAppendExecStreamParams
LcsClusterAppendExecStreamTest
Class used to dump the contents of a cluster page using fennel trace
Header stored on each page of a cluster
Constructs a cluster page, managing the amount of space currently in use on the page and determining the offsets where different elements are to be stored
Reads blocks from a single cluster
Given a stream of tuples corresponding to the column values in a cluster, creates a new cluster, replacing the pre-existing cluster with the new input tuples
LcsClusterReplaceExecStreamParams
LcsClusterReplaceExecStreamTest
Test class for exercising LcsClusterReplaceExecStream
Represents a single cluster in a table cluster scan
LcsClusterVerifier is a class for verifying cluster pages
Reads RIDs from a single cluster
Theis class is passed to std::sort
LcsCompareColKeyUsingOffsetIndex
This class implements the compare logic to sort the indices to the key offset vector, by comparing the data values stored at thse offsets
LcsHash class is used by LcsclusterAppendExecStream
LcsHashTable implements a hash table that fits the hash entries and the overflow nodes into one scratch buffer of size hashBlockSize
This class implements the hash value ordinal which is the index into the hash value nodes array stored in LcsHashTable class
LcsHashValNode contains information on every value inserted into the hash table
Testcase for loading multiple clusters
Local data structure for a column filter
Structure representing a contiguous run of rids that need to be read
Implements basic elements required to scan clusters in an exec stream
LcsRowScanBaseExecStreamParams
Indicates the clustered indexes that need to be read to scan a table and the columns from the clusters that need to be projected in the scan result
Given a stream of RIDs, performs a table scan for those RIDs using the appropriate clustered indexes defined on the table
Parameters specific to the row scan execution stream, including the type of scan (full table scan versus specific rid reads) and whether residual filtering should be performed
Testcase for scanning multiple clusters
Context for undoing the most recent insert into LcsHash
LhxAggExecStream aggregates its input, producing tuples of aggregate function computations as output
LhxAggExecStreamParams defines parameters for SortedAggExecStream
A hash function generator class that uses different seed values for each level, so that with the same key, different hash values are generated for different levels
Information common to all hash execution components: join, aggregate
Class implementing the hash table used in Hybrid Hash Join
Class to use to dump the content of a LhxHashTable
Testcase for inserting into hash table
LhxJoinExecStream matches two input streams by using a hash table built from one of the inputs(usually the smaller input)
Classes to manage hash join partitions in memory and on disk
LinearDeviceSegment is an implementation of Segment in terms of a contiguous range of pages of a single underlying RandomAccessDevice
LinearDeviceSegmentParams defines initialization parameters for LinearDeviceSegment
LinearViewSegment is an implementation of Segment in terms of an underlying Segment, which must support the get/setPageSuccessor interface
LockHolderId encapsulates the identity of an entity which can hold a lock, currently either a transaction or a thread
LogicalRecoveryLog is the recovery-time counterpart to the online LogicalTxnLog
LogicalRecoveryTxn implements recovery for transactions previously logged via LogicalTxn
LogicalTxn represents a transaction implemented via a logical logging strategy
Logged header for a single logical action
Log record describing a transaction event
LogicalTxnLog defines the log structure used by LogicalTxn to record transaction data
LogicalTxnLogCheckpointMemento
Global information recorded during LogicalTxnLog::checkpoint; this is all the information needed to begin recovery
LogicalTxnParticipant defines an interface which must be implemented by any object which is to participate in a LogicalTxn
LogicalTxnParticipantFactory defines an interface for reconstructing instances of LogicalTxnParticipant during recovery
LogicalTxnSavepoint defines all state for a savepoint within a LogicalTxn
LRUVictim is the attributes class which must be a base for any CachePage type which will be cached using an LRUVictimPolicy
LRUVictimPolicy implements the least-recently-used policy for cache victimization
MappedPageListener defines an interface which allows a derived class to receive notifications of events on mapped pages
MappedPageListenerPredicate is an implementation of PagePredicate which returns true for pages with a given MappedPageListener
MergeExecStream produces the UNION ALL of any number of inputs
MergeExecStreamParams defines parameters for instantiating a MergeExecStream
Mixed Duplicate column generator
MockConsumerExecStream consumes data from a single input
MockConsumerExecStreamParams defines parameters for MockConsumerExecStream
MockProducerExecStream generates mock data
MockProducerExecStreamGenerator
MockProducerExecStreamGenerator defines an interface for generating a data stream
MockProducerExecStreamParams defines parameters for MockProducerExecStream
MockResourceExecStream is an exec stream that simply allocates scratch pages
A mock SegPageEntryIterSource that pre-fetches every other page, returning each page twice
ModifiedAllocationNode is a structure that keeps track of the temporary page corresponding to a modified allocation node
ModifiedPageEntry is a structure that keeps track of the number of updates made to the page entry and extent entry corresponding to a page
NativeInstruction_NotANativeType< char >
NativeInstruction_NotANativeType< double >
NativeInstruction_NotANativeType< float >
NativeInstruction_NotANativeType< int >
NativeInstruction_NotANativeType< long >
NativeInstruction_NotANativeType< long long >
NativeInstruction_NotANativeType< short >
NativeInstruction_NotANativeType< signed char >
NativeInstruction_NotANativeType< unsigned char >
NativeInstruction_NotANativeType< unsigned int >
NativeInstruction_NotANativeType< unsigned long >
NativeInstruction_NotANativeType< unsigned long long >
NativeInstruction_NotANativeType< unsigned short >
NativeNativeInstruction< TMPLT >
NativeNativeInstructionRegister
NestedLoopJoinExecStream performs a nested loop join between two inputs by iterating over the first input once and opening and re-iterating over the second input for each tuple from the first
NestedLoopJoinExecStreamParams
NestedLoopJoinExecStream defines parameters for instantiating a NestedLoopJoinExecStream
Dynamic parameter used to pass a join key value from the left input to the right input
A NullMutex is a dummy class for use in cases where the need for synchronization is parameterized
Guard class for acquisition of an NullMutex
Interface for defining a stream of numbers
NumberStreamExecStreamGenerator
OpaqueInteger is a wrapper for a primitive integer type
PageBucket represents a bucket of Pages which share something in common
Embedded link class for PageBucket lists
Allocation status for a single data page
Callback class for Cache::checkpointPages
PagingTestBase is a common base for multi-threaded tests which exercise cache paging
ParallelExecResult represents the result of a task submitted to ParallelExecStreamScheduler's thread pool
ParallelExecStreamScheduler is a parallel implementation of the ExecStreamScheduler interface
ParallelExecStreamScheduler::StreamStateMapEntry
ParallelExecStreamSchedulerTest
ParallelExecStreamSchedulerTest repeats the tests from ExecStreamTestSuite, but using a parallel scheduler
ParallelExecTask represents a task submitted to ParallelExecStreamScheduler's thread pool
Decreases length by op2, which may be completely invalid
PointerInstruction_NotAPointerType< char * >
PointerInstruction_NotAPointerType< double * >
PointerInstruction_NotAPointerType< float * >
PointerInstruction_NotAPointerType< int * >
PointerInstruction_NotAPointerType< long * >
PointerInstruction_NotAPointerType< long long * >
PointerInstruction_NotAPointerType< short * >
PointerInstruction_NotAPointerType< signed char * >
PointerInstruction_NotAPointerType< unsigned char * >
PointerInstruction_NotAPointerType< unsigned int * >
PointerInstruction_NotAPointerType< unsigned long * >
PointerInstruction_NotAPointerType< unsigned long long * >
PointerInstruction_NotAPointerType< unsigned short * >
PointerIntegralInstruction< PTR_TYPE >
PointerIntegralInstructionRegister
Note: There cannot be a PointerIntegralPutStorage() as cbStorage, the maximum size, is always read-only
PointerPointerInstruction< PTR_TYPE, OP2T >
PointerPointerInstructionRegister
Increases length by op2, which may be completely invalid
Column generator which generates values with a Poisson distribution
PooledThread is a Thread working for a ThreadPool
ProxyBernoulliSamplingStreamDef
ProxyCartesianProductStreamDef
ProxyCmdCreateExecutionStreamGraph
ProxyCmdPrepareExecutionStreamGraph
ProxyLcsClusterAppendStreamDef
ProxyLcsClusterReplaceStreamDef
ProxyMultiUseBufferingStreamDef
Wrapper for a UUID
Generator for values of PseudoUuid
Tests the common PseudoUuid class
QuotaCacheAccessor is an implementation of CacheAccessor which keeps track of the number of locked pages and asserts that this never exceeds a given quota
Add a warning/exception to the message queue
RampDuplicateExecStreamGenerator
Duplicate stream generator
Test data generators, usually for a 45-degree ramp (output value equals input row number)
RandomAccessDevice is an interface representing any Device whose stored bytes can be accessed at random in constant time
RandomAccessFileDevice is an implementation of RandomAccessDevice in terms of a FileDevice
RandomAccessFileDeviceTest::Binding
RandomAccessFileDeviceTest::Listener
RandomAccessNullDevice is an implementation of RandomAccessDevice which acts something like /dev/null, except that it does not allow any transfers at all
RandomAccessRequest represents one logical unit of I/O against a RandomAccessDevice
RandomAccessRequestBinding binds a RandomAccessRequest to a particular memory location being read from or written to
RandomAllocationSegment refines RandomAllocationSegmentBase, defining an ExtentAllocationNode where each page entry within the segment is unversioned
RandomAllocationSegmentBase is an abstract base class that implements RANDOM_ALLOCATION in terms of an underlying segment supporting LINEAR_ALLOCATION
Column generator which produces values which are uniformly distributed between 0 and N - 1
RandomVictimPolicy implements the random policy for cache victimization
RandomVictimPolicy< PageT >::PageIterator
RawIntrusiveList is the type-unsafe implementation for the type-safe IntrusiveList template
RawIntrusiveListIter is the type-unsafe implementation for the type-safe IntrusiveListIter template
RawIntrusiveListMutator is the type-unsafe implementation for the type-safe IntrusiveListMutator template
A StandardTypeDescriptorOrdinal that allows a level of wildcarding
A typed group of accessor functions to a register
A reference to a register
How a register set is bound to data
A repeating column sequence generator
ReshapeExecStream takes its input stream, applies optional filtering on the input, projects specified columns from the input stream, and performs some very simple casting
ReshapeExecStreamParams defines parameters for ReshapeExecStream
Structure used to store information about dynamic parameters used by the ReshapeExecStream
RestartingMinusExecStreamGenerator
Generates repeating tuples resulting from minus such as
ScratchBufferExecStream is an adapter for converting the output of an upstream BUFPROV_CONSUMER producer for use by a downstream BUFPROV_PRODUCER consumer
ScratchBufferExecStreamParams defines parameters for ScratchBufferExecStream
Exception class for scratch memory allocation errors
ScratchSegment is an implementation of Segment which allocates scratch pages from the cache
SegBufferExecStream fully buffers its input (using segment storage as specified in its parameters)
SegBufferExecStreamParams defines parameters for instantiating a SegBufferExecStream
SegBufferReader is a helper class that reads data that has previously been buffered, and writes the data to its output stream
SegBufferReaderExecStream reads the buffered input written by a SegBufferWriterExecStream
SegBufferReaderExecStreamParams
SegBufferReaderExecStreamParams defines parameters for instantiating a SegBufferReaderExecStream
SegBufferWriter is a helper class that reads an input stream and writes the data into a buffer
SegBufferWriterExecStream reads its input stream and writes the data to a buffer so it can be read by one or more SegBufferReaderExecStreams
SegBufferWriterExecStreamParams
SegBufferWriterExecStreamParams defines parameters for instantiating a SegBufferWriterExecStream
SegInputStream implements the ByteInputStream interface by reading data previously written via a SegOutputStream
Segment is a virtualization layer for allocating and accessing pages of device storage via the cache
A SegmentAccessor combines a Segment with a CacheAccessor
SegmentAllocationNode is the allocation map for a run of extents in a RandomAllocationSegmentBase
SegmentAllocationNode::ExtentEntry
Allocation status for a single extent mapped by this node
SegmentFactory is a factory class for creating instances of the Segment interface
SegmentMap defines an interface for mapping a SegmentId to a loaded Segment instance
SegmentTestBase is a common base for any test of an implementation of the Segment interface
SegNodeLock refines SegPageLock to allow typecasting to be hidden
SegOutputStream implements the ByteOutputStream interface by writing data to pages allocated from a Segment
Device used to backup and restore pages from a data segment
SegPageEntryIter extends SegPageIter
SegPageEntryIterSource< EntryT >
SegPageEntryIterSource provides the callback method that supplies pre-fetch pageIds for SegPageEntryIter
When visiting a chain of pages via Segment.getPageSuccessor, SegPageIter can be used to automatically initiate prefetches
A SegPageLock is associated with a single segment, and starts out in the unlocked state
SegStorageTestBase is a common base for any test which depends on the Segment interface
SegStream is a common base for SegInputStream and SegOutputStream
SegStreamAllocation is a helper for managing the allocation state of storage created by SegOutputStream when it is used as temp workspace
Additional header information stored on each page of SegStreams for which CRC's are requested
SegStreamMarker refines ByteStreamMarker with a physical stream position, allowing for random-access mark/reset
Header stored on each page of a SegStream
Memento for a position within a SegStream
Column generator which produces values in sequence, starting at start, optionally with a fixed offset between each value
SequentialByteStreamMarker is a default implementation of ByteStreamMarker based on sequential byte position
SimpleExecStreamGovernor is a reference implementation of ExecStreamGovernor
SingleInputExecStream is an abstract base for all implementations of ExecStream which have exactly one input
SingleInputExecStreamParams defines parameters for SingleInputExecStream
SingleOutputExecStream is an abstract base for all implementations of ExecStream which have exactly one output
SingleOutputExecStreamParams defines parameters for SingleOutputExecStream
Contains a buffer, its maximum length and current length
From (first
SnapshotRandomAllocationSegment
SnapshotRandomAllocationSegment implements a random allocation segment that provides a consistent view of the data in the segment based on a specified point in time
SnapshotSegmentTestBase is a common base for any test that uses a SnapshotRandomAllocationSegment for storage
SortedAggExecStream aggregates its input, producing tuples of aggregate function computations as output
Generates sorted (key, value count) tuples like:
SortedAggExecStreamParams defines parameters for SortedAggExecStream
SparseBitmap is an example of how to create a page-based persistent data structure using Fennel
Page header data structure for a sparse bitmap directory node
Entry in a sparse bitmap directory
Page header data structure for a sparse bitmap leaf node
Unit tests for SparseBitmap
SpillOutputStream implements the ByteOutputStream interface by starting with writes to a cache scratch page
SplitterExecStream is an adapter for aliasing the output of an upstream producer for use by several downstream consumers
SplitterExecStreamParams defines parameters for SplitterExecStream
The official SQL:2003 standard (ISO/IEC 9075:2003), which is broken up into numerous parts
The official SQL-92 standard (ISO/IEC 9075:1992)
The official SQL:1999 standard (ISO/IEC 9075:1999), which is broken up into five parts
Same as StairCaseExecStreamGenerator except for columns
A Staircase Generator
StandardTypeDescriptor provides convenience functions to StandardTypeDescriptorOrdinal enum
StandardTypeDescriptorFactory is an implementation of the StoredTypeDescriptorFactory interface capable of constructing all of the types enumerated in StandardTypeDescriptorOrdinal
StatsSource defines an interface implemented by classes which produce performance/activity statistics
StatsTarget defines an interface implemented by classes which consume performance/activity statistics
StatsTimer publishes stats snapshots from StatsSources to a StatsTarget
StoredNode is the base class for all structures used as headers for pages of stored objects
StoredTypeDescriptor is an abstract class defining the datatypes which characterize values stored in tuples, as described in the design docs
StoredTypeDescriptorFactory is an abstract factory defining how StoredTypeDescriptors are instantiated, as described in the design docs
Support structure for calculating various windowed aggregation functions (COUNT, SUM, AVG, MIN, MAX, FIRST_VALUE, LAST_VALUE) against character data
StringExecStreamGenerator defines an interface for generating a data stream of strings
SumAggComputer computes SUM(x), ignoring null values but returning null if the input is empty
An SXMutex implements a standard readers/writers exclusion scheme: any number of shared-lock threads may hold the lock at one time, during which time exclusive-lock threads are blocked; only one exclusive-lock thread may hold the lock at a time, during which all other lock-requesting threads are blocked
Guard class for acquisition of an SXMutex
SynchMonitoredObject is the base for any object needing to use the monitor synchronization pattern
Exception class for failed system calls
SystemSamplingExecStreamGenerator
TestBase is the common base for all Fennel tests
Collects a group of named test-case definitions
Subclass of Calculator specialized for testing extended instructions
Tests the command-line options features of TestBase
TestWrapperTemplate< UserTestClass >
TestWrapperTemplate wraps a test class with setUp/tearDown hooks around each test case method invocation
Thread is a wrapper around boost::thread which allows for the thread object to be created before it is actually started
ThreadedTestBase is a common base for tests which execute multiple threads with various operations over a configurable duration
ThreadPool is a very simple thread-pooling implementation
ThreadPoolBase defines the non-templated portion of ThreadPool
ThreadPoolScheduler implements DeviceAccessScheduler by combining a thread pool with synchronous I/O calls
ThreadTracker defines an interface for receiving callbacks before and after a thread runs
TimerThread implements a timer callback via a dedicated thread
TimerThreadClient receives callbacks from a TimerThread
TraceSource is a common base for all classes which write messages to a TraceTarget
TraceTarget defines a tracing interface to be implemented by callers to Fennel
TracingSegment implements tracing for the Segment interface
TransactionalCacheAccessor implements the CacheAccessor::setTxnId method, allowing it to be used to lock pages on behalf of a particular transaction without the caller being aware of the association
TupleAccessor defines how to efficiently marshal and unmarshal values in a stored tuple
A TupleAttributeDescriptor is a component of a TupleDescriptor, as explained in the design docs
TupleData is an in-memory collection of independent data values, as explained in the design docs
TupleDataWithBuffer is a convenience that creates a TupleData, and a supporting buffer from a TupleDescriptor
A TupleDatum is a component of TupleData; see the design docs for more details
A TupleDescriptor specifies a vector of stored attributes, as explained in the design docs
Exception class to be thrown when an oversized tuple is encountered
A TupleProjection specifies a projection of a tuple, as explained in the design docs
A TupleProjectionAccessor provides a way to efficiently unmarshal selected attributes of a tuple, as explained in the design docs
TwoQDirtyPage is the attribute class that contains information about dirty pages
TwoQDirtyPageListIter< PageT >
TwoQDirtyPageListIter iterates over queues containing dirty nodes, returning the parent pages corresponding to the dirty nodes
TwoQPageListIter iterates over queues containing pages
TwoQPageQueue is used to implement the page queues used by the TwoQVictimPolicy
TwoQVictim is the attributes class which must be a base for any CachePage type which will be cached using a TwoQVictimPolicy
TwoQVictimPolicy implements the 2Q page victimization policy as described in the VLDB '94 paper "2Q: A Low Overhead High Performance Buffer Management Replacement Algorithm" by Johnson and Shasha
UnalignedAttributeAccessor is similar to AttributeAccessor, except that it provides a by-value access model intended for storing individual data values with maximum compression (hence unaligned), as opposed to the tuple-valued by-reference model of AttributeAccessor
Ouputs all tuples that previously has been collected by CollectExecStream
UncollectExecStreamParams defines parameters for instantiating a UncollectExecStream
Unions multiple number streams from 1
ValuesExecStream passes a buffer of tuples passed in as a parameter into the stream on to its consumer to process
ValuesExecStreamParams defines parameters for ValuesExecStream
VarOffsetAccessor accesses subsequent variable-width attributes that are NOT NULL
VersionedExtentAllocationNode is the allocation map for one extent in a VersionedRandomAllocationSegment
Allocation status for a single data page in this extent
Information stored in the footer of each page of a VersionedSegment
VersionedRandomAllocationSegment
VersionedRandomAllocationSegment refines RandomAllocationSegmentBase, defining a VersionedExtentAllocationNode where each page entry within the segment is versioned
VersionedSegment provides versioned updates to an underlying data segment by keeping before-images of modified pages in a separate write-ahead log segment
VMAllocator is an implementation of the CacheAllocator interface in terms of OS page allocation calls
VoidPtrHash can be used to create a hash_map or hash_set with pointers as keys
WALSegment is an implementation of Segment which keeps track of pages as they are dirtied and flushed
Support structure for calculating various windowed aggregation functions (COUNT, SUM, AVG, MIN, MAX, FIRST_VALUE, LAST_VALUE)