Fennel Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
AbortExcnException class for aborted execution
AggComputerAbstract base class representing computation of a single aggregate function over a collection of scalar values all having the same group key
AggInvocationAggInvocation represents one call to an aggregate function
AioLinuxSchedulerAioLinuxScheduler implements DeviceAccessScheduler via Linux-specific kernel-mode libaio calls
AioPollingSchedulerAioPollingScheduler implements DeviceAccessScheduler via Unix aio calls and threads which poll for completion
AioSignalSchedulerAioSignalScheduler implements DeviceAccessScheduler via Unix aio calls and threads which run a signal handler
AtomicCounterAtomicCounter wraps STL support for atomic increment/decrement
AttributeAccessorAttributeAccessor defines how to efficiently unmarshal the value of an attribute from a stored tuple
AttributeAccessorImplAttributeAccessorImpl is a common base for all implementations of the AttributeAccessor interface
AutoBacktraceAutoBacktrace provides a handler that intercepts fatal errors, prints a backtrace, and passes on the fatal error to other handlers
BacktraceA Backtrace represents a backtrace of the run-time stack
BackupRestorePageRandom access request binding for I/O requests issued during backup/restore
BackupRestoreTestUnit test for backup and restore of database header pages and a VersionedRandomAllocationSegment
BarrierExecStreamBarrierExecStream is a synchronizing barrier to wait for the completion of several upstream producers and generate a status output for the downstream consumer
BarrierExecStreamParamsBarrierExecStreamParams defines parameters for BarrierExecStream
BernoulliRngBernoulliRng produces a series of values with a Bernoulli distribution
BernoulliSamplingExecStreamBernoulliSamplingExecStream implements TABLESAMPLE BERNOULLI
BernoulliSamplingExecStreamGeneratorBernoulli sampling data generator
BernoulliSamplingExecStreamParamsBernoulliSamplingExecStreamParams defines parameters for BernoulliSamplingExecStream
BitAccessorBitAccessor accesses NOT NULL bit attributes
BitmapInputStructure containing information about the constructed bitmaps corresponding the inputs and expected result
BoolNativeEqual< TMPLT >
BoolNativeGreater< TMPLT >
BoolNativeGreaterEqual< TMPLT >
BoolNativeInstruction< TMPLT >Support for operators that return booleans, i.e
BoolNativeIsNotNull< TMPLT >
BoolNativeIsNull< TMPLT >
BoolNativeLess< TMPLT >
BoolNativeLessEqual< TMPLT >
BoolNativeNotEqual< TMPLT >
BoolPointerEqual< PTR_TYPE >
BoolPointerGreater< PTR_TYPE >
BoolPointerGreaterEqual< PTR_TYPE >
BoolPointerInstruction< PTR_TYPE >Support for operators that return booleans, i.e
BoolPointerIsNotNull< PTR_TYPE >
BoolPointerIsNull< PTR_TYPE >
BoolPointerLess< PTR_TYPE >
BoolPointerLessEqual< PTR_TYPE >
BoolPointerNotEqual< PTR_TYPE >
BTreeAccessBaseBTreeAccessBase is a base for classes which access BTree contents
BTreeBuilderBTreeBuilder implements bulk load for BTrees
BTreeBuildLevelBTreeBuildLevel is subordinate to BTreeBuilder
BTreeCompactNodeAccessorBTreeCompactNodeAccessor 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
BTreeDescriptorBTreeDescriptor defines the information required for accessing a BTree
BTreeDuplicateKeyExcnException class for duplicate keys encountered during insert or update
BTreeExecStreamBTreeExecStream is a common base for ExecStream implementations which access BTrees
BTreeExecStreamParamsBTreeExecStreamParams defines parameters common to implementations of BTreeExecStream
BTreeHeapNodeAccessorBTreeHeapNodeAccessor maintains the data on a BTreeNode using a standard indirection scheme
BTreeInsertExecStreamBTreeInsertExecStream inserts tuples into a BTree, reading them from an upstream stream producer
BTreeInsertExecStreamParamsBTreeInserterParams defines parameters for instantiating a BTreeInserter
BTreeKeyedNodeAccessor< NodeAccessor, KeyAccessor >BTreeKeyedNodeAccessor is a template for implementing some of the virtual methods in the BTreeNodeAccessor interface
BTreeLeafReaderBTreeLeafReader extends BTreeReader by only doing reads of leaf pages in a btree
BTreeNodeHeader stored on each page of a BTree
BTreeNodeAccessorBTreeNodeAccessor is an abstract base class for accessing the sorted tuple data stored on a BTreeNode
BTreeNonLeafReaderBTreeNonLeafReader extends BTreeReader by only doing reads of non-leaf pages in a btree
BTreeParamsBTreeParams defines parameters used when accessing btrees
BTreePrefetchSearchExecStreamBTreePrefetchSearchExecStream extends BTreeSearchExecStream by pre-fetching index leaf pages
BTreePrefetchSearchExecStreamParamsBTreePrefetchSearchExecStreamParams defines parameters for instantiating a BTreePrefetchSearchExecStream
BTreePrefetchSearchKeyStructure used to store the search key information that was used to locate a pre-fetched btree leaf page
BTreeReaderBTreeReader provides read-only access to the contents of a BTree
BTreeReader::NullPageStackDummy stack implementation used when we don't care about keeping track of PageId's on the way down
BTreeReadersTestThis test unit tests the BTreeNonLeafReader and BTreeLeafReader classes
BTreeReadExecStreamBTreeReadExecStream is an abstract base class for ExecStream implementations which project a stream of tuples via a BTreeReader
BTreeReadExecStreamParamsBTreeReadExecStreamParams defines parameters for instantiating a BTreeReadExecStream
BTreeRecoveryFactoryBTreeRecoveryFactory implements the LogicalTxnParticipantFactory interface by constructing BTreeWriters to be used for recovery
BTreeScanExecStreamBTreeScanExecStream reads all data from a BTree
BTreeScanExecStreamParamsBTreeScanExecStreamParams defines parameters for instantiating a BTreeScanExecStream
BTreeSearchExecStreamBTreeSearchExecStream reads keys from a child and returns matching tuples in the BTree
BTreeSearchExecStreamParamsBTreeSearchExecStreamParams defines parameters for instantiating a BTreeSearchExecStream
BTreeSearchKeyParameterStructure used to store information about dynamic parameters used in the btree search
BTreeSearchUniqueExecStreamBTreeSearchUniqueExecStream is a specialization of BTreeSearchExecStream for the case where it is known that each search is guaranteed to find at most one match
BTreeSortExecStreamBTreeSortExecStream sorts its input stream according to a parameterized key and returns the sorted data as its output, using a BTree to accomplish the sort
BTreeSortExecStreamParamsBTreeSortExecStreamParams defines parameters for instantiating a BTreeSortExecStream
BTreeStatisticsBTreeStatistics is used to return information about the tree computed as a side-effect of verification
BTreeVerifierBTreeVerifier checks BTree integrity
BTreeWriterBTreeWriter extends BTreeReader to provide read-write access to the contents of a BTree
ByteArrayInputStreamByteArrayInputStream implements the ByteInputStream interface by reading data from an existing fixed-size array of bytes
ByteArrayOutputStreamByteArrayOutputStream implements the ByteOutputStream interface by writing data to an existing fixed-size array of bytes
ByteBufferByteBuffer allows access to an array of buffers as a single memory space
ByteInputStreamByteInputStream defines an interface for reading from a stream of bytes
ByteOutputStreamByteOutputStream defines an interface for writing to a stream of bytes
ByteStreamByteStream is a common base class for ByteInputStream and ByteOutputStream
ByteStreamMarkerByteStreamMarker is an opaque position within a ByteStream
ByteWindow< IndexT >ByteWindow represents a window into a large array of bytes
CacheCache defines an abstract interface for caching pages of devices
CacheAccessorCacheAccessor defines the subset of the Cache interface used for accessing cache pages
CacheAllocatorCacheAllocator 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
CachePageCachePage is a descriptor for the state of a page of cache memory
CacheParamsCacheParams defines parameters used to instantiate a Cache
CacheStatsCacheStats defines performance/activity statistics collected by the cache; these can be obtained as a snapshot from Cache::collectStats()
CacheTestCacheTest exercises the entire Cache interface in both single-threaded and multi-threaded modes
CacheTestBaseCacheTestBase is a common base for any test which depends on the Cache interface
CalcAssemblerThe CalcAssembler is responsible for taking a textual representation of a calculator program and forming a calculator
CalcAssemblerExceptionA CalcAssemblerException represents a exception generated by the CalcAssembler while assembling a calculator program
CalcExcnException class for errors encountered during calculator execution
CalcExecStreamCalcExecStream reads tuples from a child stream and performs calculations of SQL expressions
CalcExecStreamParamsCalcExecStreamParams defines parameters for instantiating a CalcExecStream
CalcExecStreamTestSuiteCalcExecStreamTestSuite tests the CalcExecStream
CalcLexerCalcLexer is the scanner class used by the assembler to tokenize a calculator program
CalcMessageAn object for passing warning and error messages from execution
CalcTestInfo< T >
CalcTokenUnionCalcTokenUnion is an union of the possible basic types that a token/expression can be in the calculator grammar
CalcTokenValueCalcTokenValue is the data type of the sematic values of the tokens
CalcYYLocTypeCalcYYLocType provides the location of the token or expression being parsed
CartesianJoinExecStreamCartesianJoinExecStream produces the Cartesian product of two input streams
CartesianJoinExecStreamParamsCartesianJoinExecStreamParams defines parameters for instantiating a CartesianJoinExecStream
CastInstruction< RESULT_T, SOURCE_T >Instructions that cast between types
CheckpointProviderCheckpointProvider defines an interface for requesting a checkpoint
CheckpointThreadCheckpointThread is dedicated to listening for checkpoint requests and carrying them out
CircularBuffer< T >A circular buffer containing a maximum of N entries of type T
CircularBufferIter< T >Iterator over a circular buffer
CircularSegmentCircularSegment implements circular page allocation in terms of an underlying LINEAR_ALLOCATION segment
ClosableObjectClosableObject is a common base for all classes which require a close() method to be called before destruction (e.g
ClosableObjectDestructorA destructor functor for use as the "D" parameter to a boost::shared_ptr constructor
ClusterPageDataInformation about the cluster page
CmdInterpreterCmdInterpreter interprets command objects received via JNI from Farrago
CmdInterpreter::DbHandleHandle type for a database
CmdInterpreter::ExecutionHandleHandle type for storing execution state information
CmdInterpreter::TxnHandleHandle type which combines a database with a txn
CollectExecStreamCollectExecStream reads all tuples from a child stream and collects them into a single tuple which is written to one output tuple
CollectExecStreamParamsCollectExecStreamParams defines parameters for instantiating a CollectExecStream
CollectExecStreamTestSuiteTest Suite for the collect/uncollect xo's
ColumnGenerator< T >Column generator
CompositeExecStreamGeneratorGenerates a result set consisting of columns each generated by its own generator
CompoundIdCompoundId is a collection of static methods for manipulating PageIds, BlockIds, and SegByteIds
ConduitExecStreamConduitExecStream is an abstract base for any ExecStream with exactly one input and one output
ConduitExecStreamParamsConduitExecStreamParams defines parameters for ConduitExecStream
ConfigMapConfigMap defines a simple container for configuration parameter/value pairs
ConfluenceExecStreamConfluenceExecStream is an abstract base for any ExecStream with multiple inputs and exactly one output
ConfluenceExecStreamParamsConfluenceExecStreamParams defines parameters for ConfluenceExecStream
ConstColumnGeneratorConstant column generator
CopyExecStreamCopyExecStream is an adapter for converting the output of a BUFPROV_PRODUCER producer stream for use by a BUFPROF_CONSUMER consumer stream
CopyExecStreamParamsCopyExecStreamParams defines parameters for CopyExecStream
CorrelationMapping an id to an left input column
CorrelationJoinExecStreamCorrelationJoinExecStream produces a join of two input streams
CorrelationJoinExecStreamParamsCorrelationJoinExecStreamParams defines parameters for instantiating a CorrelationJoinExecStream
CountAggComputerCountAggComputer is an abstract base for computing COUNT()
CountNullableAggComputerCountNullableAggComputer computes COUNT(X), which does not count tuples for which X IS NULL
CountStarAggComputerCountStarAggComputer computes COUNT(*), which counts tuples without regard for null values
CrcSegInputStreamCrcSegInputStream extends SegInputStream by verifying checksum information on each page read
CrcSegOutputStreamCrcSegOutputStream extends SegOutputStream by stamping each page with a CRC/PseudoUuid/PageId combination
DatabaseDatabase defines the top-level database object, which is the unit of self-contained storage and recovery
DatabaseHeaderHeader stored in the first two pages of a Database data file
DataFormatExcnException class for incompatible data format errors
DataVisitorVisitor interface for dump/check/repair functions
DelegatingCacheAccessorDelegatingCacheAccessor is a common base class for all implementations of CacheAccessor which delegate part of their behavior to another underlying CacheAccessor
DelegatingSegmentDelegatingSegment is a common base class for all Segments which delegate part of their behavior to another underlying Segment
DeviceAccessSchedulerDeviceAccessScheduler is an interface representing the ability to initiate access requests on devices and handle their completions asynchronously
DeviceAccessSchedulerParamsDeviceAccessSchedulerParams defines parameters used to create a DeviceAccessScheduler
DeviceIdPagePredicateDeviceIdPagePredicate is an implementation of PagePredicate which returns true for pages mapped to a given DeviceId
DfsTreeExecStreamSchedulerDfsTreeExecStreamScheduler is a reference implementation of the ExecStreamScheduler interface
DiffluenceExecStreamDiffluenceExecStream is an abstract base for any ExecStream with multiple outputs and exactly one input
DiffluenceExecStreamParamsDiffluenceExecStreamParams defines parameters for DiffluenceExecStream
DoubleBufferExecStreamDoubleBufferExecStream 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
DoubleBufferExecStreamParamsDoubleBufferExecStreamParams defines parameters for DoubleBufferExecStream
DupColumnGeneratorDuplicate column generator
DupRepeatingSeqColumnGeneratorA duplicating repeating column sequence generator
DynamicDelegatingSegmentDynamicDelegatingSegment is similar to DelegatingSegment, except the delegating segment can be dynamically changed during the life of the segment
DynamicParamDynamic parameters are parameters (physically tuples) shared amongst streams
DynamicParamExecStreamGeneratorOutputs the value of a specified dynamic param, reinterpreted as int64_t
DynamicParamManagerDynamicParamManager defines methods to allocate, access, and deallocate dynamic parameters
ErrorSourceErrorSource is a common base for all classes that post row exceptions to an ErrorTarget
ErrorTargetErrorTarget defines an interface for receiving Fennel row errors
ExecStreamExecStream defines an abstract base for all execution objects which process streams of data
ExecStreamBufAccessorExecStreamBufAccessor defines access to the buffer memory via which ExecStreams transfer data
ExecStreamBuilderExecStreamBuilder builds a prepared ExecStreamGraph from its Java representation
ExecStreamEmbryoExecStreamEmbryo 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
ExecStreamFactoryExecStreamFactory builds an ExecStreamEmbryo from the Java representation of a stream definition
ExecStreamGovernorExecStreamGovernor defines an abstract base for determining resource allocation for an execution stream graph as well as the individual execution streams within the graph
ExecStreamGovernorTestTestcase for the exec stream resource governor
ExecStreamGraphAn ExecStreamGraph is a directed graph representing dataflow among ExecStreams
ExecStreamGraphEmbryoExecStreamGraphEmbryo encapsulates the "embryonic" state of an ExecStreamGraph as its constituent embryonic streams are built up
ExecStreamGraphImplExecStreamGraphImpl is an implementation for the ExecStreamGraph interface based on the boost graph template
ExecStreamHowToExecStreamHowTo is a guide to writing new implementations of the ExecStream interface and plugging them into Farrago
ExecStreamParamsCommon parameters for instantiating any ExecStream
ExecStreamQuantumExecStreamQuantum defines the quantum for scheduling of an ExecStream
ExecStreamResourceKnobsExecStreamResourceKnobs is a structure that stores the settings of the different knobs that are used to determine exec stream resource allocation
ExecStreamResourceQuantityExecStreamResourceQuantity quantifies various resources which can be allocated to an ExecStream
ExecStreamResourceRequirementsStructure used to track the resource requirements for a single stream
ExecStreamSchedulerExecStreamScheduler defines an abstract base for controlling the scheduling of execution streams
ExecStreamTestBaseExecStreamTestBase is a common base for tests of ExecStream implementations
ExecStreamTestSuiteExecStreamTestSuite tests various implementations of ExecStream
ExecStreamUnitTestBaseExecStreamUnitTestBase extends ExecStreamTestBase to be the common base of the unit tests of ExecStreams which assume a single stream graph
ExtendedInstructionBase class for all extended instructions
ExtendedInstruction0Extended instruction which takes 0 parameters and is implemented using a functor
ExtendedInstruction0ContextExtended instruction which takes 0 parameters and is implemented using a functor
ExtendedInstruction1< T0 >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
ExtendedInstructionContextA abstract base class for Extended Instructions that wish to store context between exec() calls
ExtendedInstructionDefDescribes an extended instruction
ExtendedInstructionTableA singleton mapping of ExtendedInstruction signatures to ExtendedInstruction functors
ExtentAllocationNodeExtentAllocationNode is the allocation map for one extent in a RandomAllocationSegment
ExternalSortExecStreamExternalSortExecStream sorts its input stream according to a parameterized key and returns the sorted data as its output
ExternalSortExecStreamImplExternalSortExecStreamImpl implements the ExternalSortExecStream interface
ExternalSortExecStreamParamsExternalSortExecStreamParams defines parameters for instantiating an ExternalSortExecStream
ExternalSortFetchArrayData structure used for array fetch when reading from substreams
ExternalSortInfoGlobal information shared with sorter sub-components
ExternalSortMergeInfoTODO: doc
ExternalSortMergerExternalSortMerger manages the process of merging stored runs
ExternalSortOutputExternalSortMerger marshals XO output buffers by fetching from a top-level ExternalSortSubStream
ExternalSortRunAccessorExternalSortRunAccessor manages I/O for storing runs and reading them back
ExternalSortRunLoaderExternalSortRunLoader manages the state of a run as it is being loaded and sorted in memory
ExternalSortSubStreamFetch interface implemented by sorter subcomponents which return intermediate results
ExternalSortTaskExternalSortTask represents a task entry in the queue serviced by the parallel sorter's thread pool
ExtremeAggComputerExtremeAggComputer computes MIN/MAX, ignoring null values but returning null if the input is empty
FennelExcnBase class for all Fennel exceptions
FileDeviceFileDevice is a base class for devices built atop the OS file system
FileStatsTargetFileStatsTarget implements the StatsTarget interface by writing to a simple text file
FileSystemFileSystem 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
FixedWidthAccessorFixedWidthAccessor accesses NOT NULL fixed width attributes
FixedWidthNetworkAccessor16FixedWidthNetworkAccessor16 accesses NOT NULL fixed width 16-bit attributes in network byte order
FixedWidthNetworkAccessor32FixedWidthNetworkAccessor32 accesses NOT NULL fixed width 32-bit attributes in network byte order
FixedWidthNetworkAccessor64FixedWidthNetworkAccessor64 accesses NOT NULL fixed width 64-bit attributes in network byte order
FlatFileBufferFlatFileBuffer provides data for FlatFileExecStream
FlatFileColumnDescriptorDescribes characteristics of a column to be parsed
FlatFileColumnParseResultResult of scanning for a column in a flat file format buffer
FlatFileExecStreamFlatFileExecStream parses a text file and produces tuples according to a specified column format
FlatFileExecStreamImplFlatFileExecStreamImpl implements the FlatFileExecStream interface
FlatFileExecStreamParamsFlatFileExecStreamParams defines parameters for instantiating a FlatFileExecStream
FlatFileParserThis class parses fields and rows from a field delimited text buffer
FlatFileRowDescriptorDescribes a vector of columns to be parsed
FlatFileRowParseResultResult of scanning for a row in a flat file format buffer
FtrsTableWriterFtrsTableWriter performs inserts, updates, and deletes on the indexes making up a table
FtrsTableWriterExecStreamFtrsTableWriterExecStream 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)
FtrsTableWriterExecStreamParamsFtrsTableWriterExecStreamParams defines parameters for instantiating a FtrsTableWriterExecStream
FtrsTableWriterFactoryFtrsTableWriterFactory implements the LogicalTxnParticipantFactory interface by constructing FtrsTableWriters to be used for recovery
FtrsTableWriterParamsFtrsTableWriterParams defines parameters for instantiating a FtrsTableWriter
FunctorExtendedInstructionDef< T >Definition of an extended instruction based upon a functor
FuzzyCheckpointSetFuzzyCheckpointSet keeps track of dirty pages at the time of a checkpoint
GroupLockGroupLock is a synchronization object for enforcing mutual exclusion among an indefinite number of groups with indefinite cardinalities
std::hash< fennel::OpaqueInteger< T, Dummy > >
InputDataStructure for passing input data corresponding to bitmap inputs and expected result
InstructionDescriptionDescription of an instruction
InstructionFactoryDynamically create Instruction objects given an InstructionDescription description of the desired Instruction
InstructionRegisterProvide a method to register Instruction objects into the Instruction Factory
IntegralNativeAnd< TMPLT >
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 >
IntegralNativeMod< TMPLT >
IntegralNativeOr< TMPLT >
IntegralNativeShiftLeft< TMPLT >
IntegralNativeShiftRight< TMPLT >
IntegralPointerInstruction< PTR_TYPE >PointerSizeT is the only valid result type defined for IntegralPointerInstruction
IntrusiveDListIter< T >Iterator over an intrusive doubly-linked list
IntrusiveDListNodeA 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
IntrusiveListNodeSee class IntrusiveList for details
IntrusiveTwoDListIter< ElementT, ReturnT >Iterator over two intrusive doubly-linked lists
InvalidParamExcnException class for invalid parameter settings
InvalidTypeExceptionException indicating an invalid type
InvalidValueException< T >Exception indicating a type/value mismatch
IoCompletionPortSchedulerIoCompletionPortScheduler implements DeviceAccessScheduler via the Win32 IoCompletionPort facility
JavaErrorTargetJavaErrorTarget implements ErrorTarget by calling back into the Farrago error handling facility
JavaExcnException class for wrapping Java exceptions
JavaSinkExecStreamJavaSinkExecStream reads its tuples from an upstream execution object and pumps them into Java
JavaSinkExecStreamParamsJavaSinkExecStreamParams defines parameters for instantiating a JavaSinkExecStream
JavaThreadTrackerJavaThreadTracker implements ThreadTracker by attaching and detaching the Java environment
JavaTraceTargetJavaTraceTarget implements TraceTarget by calling back into the java.util.logging facility
JavaTransformExecStreamJavaTransformExecStream represents a sequence of Java transforms encapsulated within a Fennel ExecStream
JniEnvAutoRefAn implementation of JniEnvRef which can be used in contexts where no JNIEnv is available yet
JniEnvRefWrapper for a JNIEnv pointer
JniExceptionCheckerHelper for JniEnvRef
JniLocalRefReaperGuard for deleting a local ref automatically on unwind
JniProxyJniProxy is the virtual base class for all generated proxies
JniProxyIter< T >JniProxyIter is used to access a JniProxy by reference
JniProxyVisitorJniProxyVisitor is the base for all classes which need to visit one or more instances of JniProxy polymorphically
JniProxyVisitTable< Visitor >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::VisitorMethodAbstract functor for calling the correct visit method
JniUtilStatic utility methods for dealing with JNI
JniUtilParamsJniUtilParams defines parameters used to configure JniUtil
LbmBitOpExecStreamLbmBitOpExecStream is a base class for implementing bit operation execution streams that read from N input streams
LbmBitOpExecStreamParamsLbmBitOpExecStreamParams defines parameters for instantiating a LbmBitOpExecStream
LbmByteSegmentThis class encapsulates a single byte segment, as opposed to a tuple which contains a set of them
LbmChopperExecStreamLbmChopperExecStream splits up tuples whose decompressed representations are too large to fit into the memory of associated streams
LbmChopperExecStreamParamsLbmChopperExecStreamParams defines parameters for instantiating a LbmChopperExecStream
LbmDeletionIndexReaderLbmBTreeRidReader is a class for reading RIDs from a deletion index
LbmEntryClass implementing bitmap index entries
LbmEntryDumpClass used to dump the contents of a LbmEntry
LbmEntryInfoStructure that associates a scratch buffer with each bitmap entry under construction
LbmEntryTestTestcase for LbmEntry class
LbmExecStreamTestBaseLbmExecStreamTestBase is the base class for tests of bitmap exec streams
LbmGeneratorExecStreamLbmGeneratorExecStream reads the column store clusters corresponding to the columns of an index, and creates bitmap entries for those rows
LbmIntersectExecStreamLbmIntersectExecStream is the execution stream used to perform intersection on two or more bitmap stream inputs
LbmIntersectExecStreamParamsLbmIntersectExecStreamParams defines parameters for instantiating a LbmIntersectExecStream
LbmIntersectExecStreamTestTestcase for Intersect exec stream
LbmIterableRidReaderLbmIterableRidReader provides an iterator interface to a rid reader
LbmLoadBitmapTestTestcase for loading multiple clusters
LbmMinusExecStreamLbmMinusExecStream is the execution stream that subtracts from the first bitmap input stream, the bitmap streams from the remaining inputs
LbmMinusExecStreamParamsLbmMinusExecStreamParams defines parameters for instantiating a LbmMinusExecStream
LbmMinusExecStreamTestTestcase for Minus exec stream
LbmNormalizerExecStreamThe bitmap normalizer stream expands bitmap data to tuples
LbmNormalizerExecStreamParamsThis structure defines parameters for instantiating an LbmNormalizerExecStream
LbmNormalizerExecStreamTestTest case for LbmNormalizerExecStream
LbmNumberStreamInputCombines a NumberStream with other attributes used to make test data
LbmReaderTestTest for bitmap tuple and rid reader classes
LbmRepeatingAggComputerLbmRepeatingAggComputer is an aggregate computer that wraps another aggregate computer
LbmRidReaderLbmRidReader provides an interface for reading RIDs from an input stream
LbmRidReaderBaseLbmRidReaderBase provides an interace for reading RIDs from bit segments
LbmSearchExecStreamLbmSearchExecStream is the execution stream used for scanning bitmap indexes
LbmSearchExecStreamParamsLbmSearchExecStreamParams defines parameters for instantiating a LbmSearchExecStream
LbmSearchTestTestcase for scanning a single bitmap index using equality search on all index keys
LbmSegmentClass implementing bitmap segments
LbmSegmentReaderLbmSegmentReader provides the interace necessary to read bit segments
LbmSegmentReaderBaseLbmSegmentReaderBase provides the base class for reading from bitmap segments
LbmSegmentWriterLbmSegmentWriter constructs a bitmap segment by utilizing LbmEntry to write out individual byte segments
LbmSeqSegmentReaderLbmSeqSegmentReader provides the interace necessary to read byte segments sequentially
LbmSingleTupleReaderLbmSingleTupleReader is a class satisyfing the bitmap tuple reader interface for a single input tuple
LbmSortedAggExecStreamLbmSortedAggExecStream aggregates its input, producing tuples with aggregate computations as output
LbmSortedAggExecStreamParamsLbmSortedAggExecStreamParams defines parameters for LbmSortedAggExecStream
LbmSortedAggExecStreamTestTest case for LbmSortedAggExecStream
LbmSplicerExecStreamLbmSplicerExecStream takes as input a stream of bitmap entries
LbmSplicerExecStreamTestTestcase for splicer exec stream
LbmStreamTupleReaderLbmStreamTupleReader is a base class for reading bitmap tuples from an input stream
LbmTupleReaderLbmTupleReader is an interface for reading bitmap tuples
LbmTupleRidReaderLbmTupleRidReader is a class for reading rids from bitmap tuples
LbmUnionExecStreamLbmUnionExecStream is the execution stream used to perform a union on a stream of overlapping bitmap tuple
LbmUnionExecStreamParamsLbmUnionExecStreamParams defines parameters for instantiating a LbmUnionExecStream
LbmUnionWorkspaceThe union workspace merges byte segments
LcsBatchDirBatch directory representing each batch within a cluster
LcsClusterAccessBaseLcsClusterAccessBase is a base for classes which access cluster pages
LcsClusterAppendExecStreamGiven a stream of tuples corresponding to the column values in a cluster, loads the cluster pages
LcsClusterDumpClass used to dump the contents of a cluster page using fennel trace
LcsClusterNodeHeader stored on each page of a cluster
LcsClusterNodeWriterConstructs 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
LcsClusterReaderReads blocks from a single cluster
LcsClusterReplaceExecStreamGiven 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
LcsClusterReplaceExecStreamTestTest class for exercising LcsClusterReplaceExecStream
LcsClusterScanDefRepresents a single cluster in a table cluster scan
LcsClusterVerifierLcsClusterVerifier is a class for verifying cluster pages
LcsColumnReaderReads RIDs from a single cluster
LcsCompareTheis class is passed to std::sort
LcsCompareColKeyUsingOffsetIndexThis class implements the compare logic to sort the indices to the key offset vector, by comparing the data values stored at thse offsets
LcsHashLcsHash class is used by LcsclusterAppendExecStream
LcsHashTableLcsHashTable implements a hash table that fits the hash entries and the overflow nodes into one scratch buffer of size hashBlockSize
LcsHashValOrdThis class implements the hash value ordinal which is the index into the hash value nodes array stored in LcsHashTable class
LcsHashValueNodeLcsHashValNode contains information on every value inserted into the hash table
LcsMultiClusterAppendTestTestcase for loading multiple clusters
LcsResidualFilterLocal data structure for a column filter
LcsRidRunStructure representing a contiguous run of rids that need to be read
LcsRowScanBaseExecStreamImplements basic elements required to scan clusters in an exec stream
LcsRowScanBaseExecStreamParamsIndicates 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
LcsRowScanExecStreamGiven a stream of RIDs, performs a table scan for those RIDs using the appropriate clustered indexes defined on the table
LcsRowScanExecStreamParamsParameters 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
LcsRowScanExecStreamTestTestcase for scanning multiple clusters
LcsUndoTypeContext for undoing the most recent insert into LcsHash
LhxAggExecStreamLhxAggExecStream aggregates its input, producing tuples of aggregate function computations as output
LhxAggExecStreamParamsLhxAggExecStreamParams defines parameters for SortedAggExecStream
LhxHashGeneratorA 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
LhxHashInfoInformation common to all hash execution components: join, aggregate
LhxHashNodeAccessorClass implementing the hash table used in Hybrid Hash Join
LhxHashTableDumpClass to use to dump the content of a LhxHashTable
LhxHashTableTestTestcase for inserting into hash table
LhxJoinExecStreamParamsLhxJoinExecStream matches two input streams by using a hash table built from one of the inputs(usually the smaller input)
LhxPartitionClasses to manage hash join partitions in memory and on disk
LinearDeviceSegmentLinearDeviceSegment is an implementation of Segment in terms of a contiguous range of pages of a single underlying RandomAccessDevice
LinearDeviceSegmentParamsLinearDeviceSegmentParams defines initialization parameters for LinearDeviceSegment
LinearViewSegmentLinearViewSegment is an implementation of Segment in terms of an underlying Segment, which must support the get/setPageSuccessor interface
LockHolderIdLockHolderId encapsulates the identity of an entity which can hold a lock, currently either a transaction or a thread
LogicalRecoveryLogLogicalRecoveryLog is the recovery-time counterpart to the online LogicalTxnLog
LogicalRecoveryTxnLogicalRecoveryTxn implements recovery for transactions previously logged via LogicalTxn
LogicalTxnLogicalTxn represents a transaction implemented via a logical logging strategy
LogicalTxnActionHeaderLogged header for a single logical action
LogicalTxnEventMementoLog record describing a transaction event
LogicalTxnLogLogicalTxnLog defines the log structure used by LogicalTxn to record transaction data
LogicalTxnLogCheckpointMementoGlobal information recorded during LogicalTxnLog::checkpoint; this is all the information needed to begin recovery
LogicalTxnParticipantLogicalTxnParticipant defines an interface which must be implemented by any object which is to participate in a LogicalTxn
LogicalTxnParticipantFactoryLogicalTxnParticipantFactory defines an interface for reconstructing instances of LogicalTxnParticipant during recovery
LogicalTxnSavepointLogicalTxnSavepoint defines all state for a savepoint within a LogicalTxn
LRUVictimLRUVictim is the attributes class which must be a base for any CachePage type which will be cached using an LRUVictimPolicy
LRUVictimPolicy< PageT >LRUVictimPolicy implements the least-recently-used policy for cache victimization
MappedPageListenerMappedPageListener defines an interface which allows a derived class to receive notifications of events on mapped pages
MappedPageListenerPredicateMappedPageListenerPredicate is an implementation of PagePredicate which returns true for pages with a given MappedPageListener
MergeExecStreamMergeExecStream produces the UNION ALL of any number of inputs
MergeExecStreamParamsMergeExecStreamParams defines parameters for instantiating a MergeExecStream
MixedDupColumnGeneratorMixed Duplicate column generator
MockConsumerExecStreamMockConsumerExecStream consumes data from a single input
MockConsumerExecStreamParamsMockConsumerExecStreamParams defines parameters for MockConsumerExecStream
MockProducerExecStreamMockProducerExecStream generates mock data
MockProducerExecStreamGeneratorMockProducerExecStreamGenerator defines an interface for generating a data stream
MockProducerExecStreamParamsMockProducerExecStreamParams defines parameters for MockProducerExecStream
MockResourceExecStreamMockResourceExecStream is an exec stream that simply allocates scratch pages
MockSegPageEntryIterSourceA mock SegPageEntryIterSource that pre-fetches every other page, returning each page twice
ModifiedAllocationNodeModifiedAllocationNode is a structure that keeps track of the temporary page corresponding to a modified allocation node
ModifiedPageEntryModifiedPageEntry is a structure that keeps track of the number of updates made to the page entry and extent entry corresponding to a page
NativeAdd< TMPLT >
NativeDiv< TMPLT >
NativeInstruction< TMPLT >
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 >
NativeMove< TMPLT >
NativeMul< TMPLT >
NativeNativeInstruction< TMPLT >
NativeNeg< TMPLT >
NativeRef< TMPLT >
NativeRound< TMPLT >
NativeRoundHelp< TMPLT >
NativeRoundHelp< double >
NativeRoundHelp< float >
NativeSub< TMPLT >
NativeToNull< TMPLT >
NestedLoopJoinExecStreamNestedLoopJoinExecStream 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
NestedLoopJoinExecStreamParamsNestedLoopJoinExecStream defines parameters for instantiating a NestedLoopJoinExecStream
NestedLoopJoinKeyDynamic parameter used to pass a join key value from the left input to the right input
Noisy< TMPL >
NullableAccessor< Accessor >
NullMutexA NullMutex is a dummy class for use in cases where the need for synchronization is parameterized
NullMutexGuardGuard class for acquisition of an NullMutex
NumberStreamInterface for defining a stream of numbers
NumericType< T, typeOrdinal >
OpaqueInteger< T, Dummy >OpaqueInteger is a wrapper for a primitive integer type
PageBucket< PageT >PageBucket represents a bucket of Pages which share something in common
PageBucketListNodeEmbedded link class for PageBucket lists
PageEntryAllocation status for a single data page
PagePredicateCallback class for Cache::checkpointPages
PagingTestBasePagingTestBase is a common base for multi-threaded tests which exercise cache paging
ParallelExecResultParallelExecResult represents the result of a task submitted to ParallelExecStreamScheduler's thread pool
ParallelExecStreamSchedulerParallelExecStreamScheduler is a parallel implementation of the ExecStreamScheduler interface
ParallelExecStreamSchedulerTestParallelExecStreamSchedulerTest repeats the tests from ExecStreamTestSuite, but using a parallel scheduler
ParallelExecTaskParallelExecTask represents a task submitted to ParallelExecStreamScheduler's thread pool
John V
PointerAdd< PTR_TYPE >Decreases length by op2, which may be completely invalid
PointerGetMaxSize< PTR_TYPE >
PointerGetSize< PTR_TYPE >
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 >
PointerIntegralInstructionRegisterNote: There cannot be a PointerIntegralPutStorage() as cbStorage, the maximum size, is always read-only
PointerMove< PTR_TYPE >
PointerPointerInstruction< PTR_TYPE, OP2T >
PointerPutSize< PTR_TYPE >
PointerRef< PTR_TYPE >
PointerSub< PTR_TYPE >Increases length by op2, which may be completely invalid
PointerToNull< PTR_TYPE >
PoissonColumnGenerator< T >Column generator which generates values with a Poisson distribution
PooledThreadPooledThread is a Thread working for a ThreadPool
PseudoUuidWrapper for a UUID
PseudoUuidGeneratorGenerator for values of PseudoUuid
PseudoUuidTestTests the common PseudoUuid class
QuotaCacheAccessorQuotaCacheAccessor is an implementation of CacheAccessor which keeps track of the number of locked pages and asserts that this never exceeds a given quota
RaiseInstructionAdd a warning/exception to the message queue
RampDuplicateExecStreamGeneratorDuplicate stream generator
RampExecStreamGeneratorTest data generators, usually for a 45-degree ramp (output value equals input row number)
RandomAccessDeviceRandomAccessDevice is an interface representing any Device whose stored bytes can be accessed at random in constant time
RandomAccessFileDeviceRandomAccessFileDevice is an implementation of RandomAccessDevice in terms of a FileDevice
RandomAccessNullDeviceRandomAccessNullDevice is an implementation of RandomAccessDevice which acts something like /dev/null, except that it does not allow any transfers at all
RandomAccessRequestRandomAccessRequest represents one logical unit of I/O against a RandomAccessDevice
RandomAccessRequestBindingRandomAccessRequestBinding binds a RandomAccessRequest to a particular memory location being read from or written to
RandomAllocationSegmentRandomAllocationSegment refines RandomAllocationSegmentBase, defining an ExtentAllocationNode where each page entry within the segment is unversioned
RandomAllocationSegmentBaseRandomAllocationSegmentBase is an abstract base class that implements RANDOM_ALLOCATION in terms of an underlying segment supporting LINEAR_ALLOCATION
RandomColumnGeneratorColumn generator which produces values which are uniformly distributed between 0 and N - 1
RandomVictimPolicy< PageT >RandomVictimPolicy implements the random policy for cache victimization
RandomVictimPolicy< PageT >::PageIterator
RawIntrusiveListRawIntrusiveList is the type-unsafe implementation for the type-safe IntrusiveList template
RawIntrusiveListIterRawIntrusiveListIter is the type-unsafe implementation for the type-safe IntrusiveListIter template
RawIntrusiveListMutatorRawIntrusiveListMutator is the type-unsafe implementation for the type-safe IntrusiveListMutator template
RegDescA StandardTypeDescriptorOrdinal that allows a level of wildcarding
RegisterRef< TMPLT >A typed group of accessor functions to a register
RegisterReferenceA reference to a register
RegisterSetBindingHow a register set is bound to data
RegisterTestInfo< T >
RepeatingSeqColumnGeneratorA repeating column sequence generator
ReshapeExecStreamReshapeExecStream takes its input stream, applies optional filtering on the input, projects specified columns from the input stream, and performs some very simple casting
ReshapeExecStreamParamsReshapeExecStreamParams defines parameters for ReshapeExecStream
ReshapeParameterStructure used to store information about dynamic parameters used by the ReshapeExecStream
RestartingMinusExecStreamGeneratorGenerates repeating tuples resulting from minus such as
ScratchBufferExecStreamScratchBufferExecStream is an adapter for converting the output of an upstream BUFPROV_CONSUMER producer for use by a downstream BUFPROV_PRODUCER consumer
ScratchBufferExecStreamParamsScratchBufferExecStreamParams defines parameters for ScratchBufferExecStream
ScratchMemExcnException class for scratch memory allocation errors
ScratchSegmentScratchSegment is an implementation of Segment which allocates scratch pages from the cache
SegBufferExecStreamSegBufferExecStream fully buffers its input (using segment storage as specified in its parameters)
SegBufferExecStreamParamsSegBufferExecStreamParams defines parameters for instantiating a SegBufferExecStream
SegBufferReaderSegBufferReader is a helper class that reads data that has previously been buffered, and writes the data to its output stream
SegBufferReaderExecStreamSegBufferReaderExecStream reads the buffered input written by a SegBufferWriterExecStream
SegBufferReaderExecStreamParamsSegBufferReaderExecStreamParams defines parameters for instantiating a SegBufferReaderExecStream
SegBufferWriterSegBufferWriter is a helper class that reads an input stream and writes the data into a buffer
SegBufferWriterExecStreamSegBufferWriterExecStream reads its input stream and writes the data to a buffer so it can be read by one or more SegBufferReaderExecStreams
SegBufferWriterExecStreamParamsSegBufferWriterExecStreamParams defines parameters for instantiating a SegBufferWriterExecStream
SegInputStreamSegInputStream implements the ByteInputStream interface by reading data previously written via a SegOutputStream
SegmentSegment is a virtualization layer for allocating and accessing pages of device storage via the cache
SegmentAccessorA SegmentAccessor combines a Segment with a CacheAccessor
SegmentAllocationNodeSegmentAllocationNode is the allocation map for a run of extents in a RandomAllocationSegmentBase
SegmentAllocationNode::ExtentEntryAllocation status for a single extent mapped by this node
SegmentFactorySegmentFactory is a factory class for creating instances of the Segment interface
SegmentMapSegmentMap defines an interface for mapping a SegmentId to a loaded Segment instance
SegmentTestBaseSegmentTestBase is a common base for any test of an implementation of the Segment interface
SegNodeLock< Node >SegNodeLock refines SegPageLock to allow typecasting to be hidden
SegOutputStreamSegOutputStream implements the ByteOutputStream interface by writing data to pages allocated from a Segment
SegPageBackupRestoreDeviceDevice used to backup and restore pages from a data segment
SegPageEntryIter< EntryT >SegPageEntryIter extends SegPageIter
SegPageEntryIterSource< EntryT >SegPageEntryIterSource provides the callback method that supplies pre-fetch pageIds for SegPageEntryIter
SegPageIterWhen visiting a chain of pages via Segment.getPageSuccessor, SegPageIter can be used to automatically initiate prefetches
SegPageLockA SegPageLock is associated with a single segment, and starts out in the unlocked state
SegStorageTestBaseSegStorageTestBase is a common base for any test which depends on the Segment interface
SegStreamSegStream is a common base for SegInputStream and SegOutputStream
SegStreamAllocationSegStreamAllocation is a helper for managing the allocation state of storage created by SegOutputStream when it is used as temp workspace
SegStreamCrcAdditional header information stored on each page of SegStreams for which CRC's are requested
SegStreamMarkerSegStreamMarker refines ByteStreamMarker with a physical stream position, allowing for random-access mark/reset
SegStreamNodeHeader stored on each page of a SegStream
SegStreamPositionMemento for a position within a SegStream
SeqColumnGeneratorColumn generator which produces values in sequence, starting at start, optionally with a fixed offset between each value
SequentialByteStreamMarkerSequentialByteStreamMarker is a default implementation of ByteStreamMarker based on sequential byte position
SimpleExecStreamGovernorSimpleExecStreamGovernor is a reference implementation of ExecStreamGovernor
SingleInputExecStreamSingleInputExecStream is an abstract base for all implementations of ExecStream which have exactly one input
SingleInputExecStreamParamsSingleInputExecStreamParams defines parameters for SingleInputExecStream
SingleOutputExecStreamSingleOutputExecStream is an abstract base for all implementations of ExecStream which have exactly one output
SingleOutputExecStreamParamsSingleOutputExecStreamParams defines parameters for SingleOutputExecStream
SizeBufferContains a buffer, its maximum length and current length
SkipNumberStreamFrom (first
SnapshotRandomAllocationSegmentSnapshotRandomAllocationSegment implements a random allocation segment that provides a consistent view of the data in the segment based on a specified point in time
SnapshotSegmentTestBaseSnapshotSegmentTestBase is a common base for any test that uses a SnapshotRandomAllocationSegment for storage
SortedAggExecStreamSortedAggExecStream aggregates its input, producing tuples of aggregate function computations as output
SortedAggExecStreamGeneratorGenerates sorted (key, value count) tuples like:
SortedAggExecStreamParamsSortedAggExecStreamParams defines parameters for SortedAggExecStream
SparseBitmapSparseBitmap is an example of how to create a page-based persistent data structure using Fennel
SparseBitmapDirectoryPage header data structure for a sparse bitmap directory node
SparseBitmapDirEntryEntry in a sparse bitmap directory
SparseBitmapLeafPage header data structure for a sparse bitmap leaf node
SparseBitmapTestUnit tests for SparseBitmap
SpillOutputStreamSpillOutputStream implements the ByteOutputStream interface by starting with writes to a cache scratch page
SplitterExecStreamSplitterExecStream is an adapter for aliasing the output of an upstream producer for use by several downstream consumers
SplitterExecStreamParamsSplitterExecStreamParams defines parameters for SplitterExecStream
SQL2003The official SQL:2003 standard (ISO/IEC 9075:2003), which is broken up into numerous parts
SQL92The official SQL-92 standard (ISO/IEC 9075:1992)
SQL99The official SQL:1999 standard (ISO/IEC 9075:1999), which is broken up into five parts
StairCaseColumnGeneratorSame as StairCaseExecStreamGenerator except for columns
StairCaseExecStreamGeneratorA Staircase Generator
StandardTypeDescriptorStandardTypeDescriptor provides convenience functions to StandardTypeDescriptorOrdinal enum
StandardTypeDescriptorFactoryStandardTypeDescriptorFactory is an implementation of the StoredTypeDescriptorFactory interface capable of constructing all of the types enumerated in StandardTypeDescriptorOrdinal
StatsSourceStatsSource defines an interface implemented by classes which produce performance/activity statistics
StatsTargetStatsTarget defines an interface implemented by classes which consume performance/activity statistics
StatsTimerStatsTimer publishes stats snapshots from StatsSources to a StatsTarget
StoredNodeStoredNode is the base class for all structures used as headers for pages of stored objects
StoredTypeDescriptorStoredTypeDescriptor is an abstract class defining the datatypes which characterize values stored in tuples, as described in the design docs
StoredTypeDescriptorFactoryStoredTypeDescriptorFactory is an abstract factory defining how StoredTypeDescriptors are instantiated, as described in the design docs
StringDescSupport structure for calculating various windowed aggregation functions (COUNT, SUM, AVG, MIN, MAX, FIRST_VALUE, LAST_VALUE) against character data
StringExecStreamGeneratorStringExecStreamGenerator defines an interface for generating a data stream of strings
SumAggComputer< T >SumAggComputer computes SUM(x), ignoring null values but returning null if the input is empty
SXMutexAn 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
SXMutexGuard< lockMode >Guard class for acquisition of an SXMutex
SynchMonitoredObjectSynchMonitoredObject is the base for any object needing to use the monitor synchronization pattern
SysCallExcnException class for failed system calls
TestBaseTestBase is the common base for all Fennel tests
TestBase::TestCaseGroupCollects a group of named test-case definitions
TestCalculatorSubclass of Calculator specialized for testing extended instructions
TestOptionsTestTests the command-line options features of TestBase
TestWrapperTemplate< UserTestClass >TestWrapperTemplate wraps a test class with setUp/tearDown hooks around each test case method invocation
ThreadThread is a wrapper around boost::thread which allows for the thread object to be created before it is actually started
ThreadedTestBaseThreadedTestBase is a common base for tests which execute multiple threads with various operations over a configurable duration
ThreadPool< Task >ThreadPool is a very simple thread-pooling implementation
ThreadPoolBaseThreadPoolBase defines the non-templated portion of ThreadPool
ThreadPoolSchedulerThreadPoolScheduler implements DeviceAccessScheduler by combining a thread pool with synchronous I/O calls
ThreadTrackerThreadTracker defines an interface for receiving callbacks before and after a thread runs
TimerThreadTimerThread implements a timer callback via a dedicated thread
TimerThreadClientTimerThreadClient receives callbacks from a TimerThread
TraceSourceTraceSource is a common base for all classes which write messages to a TraceTarget
TraceTargetTraceTarget defines a tracing interface to be implemented by callers to Fennel
TracingSegmentTracingSegment implements tracing for the Segment interface
TransactionalCacheAccessorTransactionalCacheAccessor 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
TupleAccessorTupleAccessor defines how to efficiently marshal and unmarshal values in a stored tuple
TupleAttributeDescriptorA TupleAttributeDescriptor is a component of a TupleDescriptor, as explained in the design docs
TupleDataTupleData is an in-memory collection of independent data values, as explained in the design docs
TupleDataWithBufferTupleDataWithBuffer is a convenience that creates a TupleData, and a supporting buffer from a TupleDescriptor
TupleDatumA TupleDatum is a component of TupleData; see the design docs for more details
TupleDescriptorA TupleDescriptor specifies a vector of stored attributes, as explained in the design docs
TupleOverflowExcnException class to be thrown when an oversized tuple is encountered
TupleProjectionA TupleProjection specifies a projection of a tuple, as explained in the design docs
TupleProjectionAccessorA TupleProjectionAccessor provides a way to efficiently unmarshal selected attributes of a tuple, as explained in the design docs
TwoQDirtyPageTwoQDirtyPage 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< PageT >TwoQPageListIter iterates over queues containing pages
TwoQPageQueueTwoQPageQueue is used to implement the page queues used by the TwoQVictimPolicy
TwoQVictimTwoQVictim is the attributes class which must be a base for any CachePage type which will be cached using a TwoQVictimPolicy
TwoQVictimPolicy< PageT >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
UnalignedAttributeAccessorUnalignedAttributeAccessor 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
UncollectExecStreamOuputs all tuples that previously has been collected by CollectExecStream
UncollectExecStreamParamsUncollectExecStreamParams defines parameters for instantiating a UncollectExecStream
UnionNumberStreamUnions multiple number streams from 1
ValuesExecStreamValuesExecStream passes a buffer of tuples passed in as a parameter into the stream on to its consumer to process
ValuesExecStreamParamsValuesExecStreamParams defines parameters for ValuesExecStream
VarOffsetAccessor< network >VarOffsetAccessor accesses subsequent variable-width attributes that are NOT NULL
VersionedExtentAllocationNodeVersionedExtentAllocationNode is the allocation map for one extent in a VersionedRandomAllocationSegment
VersionedPageEntryAllocation status for a single data page in this extent
VersionedPageFooterInformation stored in the footer of each page of a VersionedSegment
VersionedRandomAllocationSegmentVersionedRandomAllocationSegment refines RandomAllocationSegmentBase, defining a VersionedExtentAllocationNode where each page entry within the segment is versioned
VersionedSegmentVersionedSegment provides versioned updates to an underlying data segment by keeping before-images of modified pages in a separate write-ahead log segment
VMAllocatorVMAllocator is an implementation of the CacheAllocator interface in terms of OS page allocation calls
VoidPtrHashVoidPtrHash can be used to create a hash_map or hash_set with pointers as keys
WALSegmentWALSegment is an implementation of Segment which keeps track of pages as they are dirtied and flushed
WinAggHistogram< STDTYPE >Support structure for calculating various windowed aggregation functions (COUNT, SUM, AVG, MIN, MAX, FIRST_VALUE, LAST_VALUE)

Generated on Mon Jun 22 04:00:23 2009 for Fennel by  doxygen 1.5.1