LbmSearchTest Class Reference

Testcase for scanning a single bitmap index using equality search on all index keys. More...

Inheritance diagram for LbmSearchTest:

List of all members.

Public Member Functions
	LbmSearchTest ()
void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
void	testScans (uint nRows)
void	testScanOneLevel ()
void	testScanTwoLevel ()
void	testMultipleRanges ()
virtual void	openStorage (DeviceMode openMode)
virtual void	openSegmentStorage (DeviceMode openMode)
virtual void	openRandomSegment ()
SharedSegment	createLinearDeviceSegment (DeviceId deviceId, uint nPages)
void	closeLinearSegment ()
void	closeRandomSegment ()
void	closeVersionedRandomSegment ()
void	closeSnapshotRandomSegment ()
virtual void	closeStorage ()
Cache &	getCache ()
virtual SharedCache	newCache ()
SharedRandomAccessDevice	openDevice (std::string devName, DeviceMode openMode, uint nDevicePages, DeviceId deviceId)
void	closeDevice (DeviceId deviceId, SharedRandomAccessDevice &pDevice)
TestSuite *	releaseTestSuite ()
void	beforeTestCase (std::string testCaseName)
void	afterTestCase (std::string testCaseName)
virtual void	notifyTrace (std::string source, TraceLevel level, std::string message)
	Receives notification when a trace event occurs.
virtual TraceLevel	getSourceTraceLevel (std::string source)
	Gets the level at which a particular source should be traced.
Static Public Member Functions
static uint	getTupleInterval (std::vector< int > const &repeatSeqValues, uint nKeys=0)
	Find the interval for which an entire tuple's sequence repeats.
static void	readParams (int argc, char **argv)
	Parses the command line.
Static Public Attributes
static ParamName	paramTestSuiteName
static ParamName	paramTraceFileName
static ParamName	paramDictionaryFileName
static ParamName	paramTraceLevel
static ParamName	paramStatsFileName
static ParamName	paramTraceStdout
static ParamName	paramDegreeOfParallelism
static ConfigMap	configMap
	Configuration parameters.
Protected Types
enum	VictimPolicy { victimTwoQ, victimLRU, victimRandom }
	The available victim policy implementations. More...
Protected Member Functions
void	initBTreeExecStreamParam (BTreeExecStreamParams &param, shared_ptr< BTreeDescriptor > pBTreeDesc)
	Initializes a BTreeExecStreamParam structure.
void	initBTreeParam (BTreeParams &param, shared_ptr< BTreeDescriptor > pBTreeDesc)
	Initializes BTreeParams structure.
void	initClusterScanDef (LcsRowScanBaseExecStreamParams &generatorParams, struct LcsClusterScanDef &clusterScanDef, uint bTreeIndex)
	Initializes a cluster scan def structure for a LcsRowScanBase exec stream.
void	initBTreeBitmapDesc (TupleDescriptor &tupleDesc, TupleProjection &keyProj, uint nKeys)
	Initializes BTreeExecStreamParam corresponding to a bitmap index.
void	initBTreeTupleDesc (TupleDescriptor &tupleDesc, uint nKeys)
	Initializes a tuple descriptor corresponding to a bitmap index.
void	loadTableAndIndex (uint nRows, uint nClusters, std::vector< int > const &repeatSeqValues, bool newRoot)
	Loads a table with nClusters clusters, 1 column per cluster, and nRows rows.
void	testScanFullKey (uint nRows, uint nKeys, std::vector< int > const &repeatSeqValues, bool useDynamicKeys, bool includeRid)
	Tests equality scan on the table created in loadTableAndIndex, using the entire index key (minus the rid).
void	testScanPartialKey (uint nRows, uint nKeys, std::vector< int > const &repeatSeqValues)
	Tests equality scan on the table created in loadTableAndIndex, using the all keys except the rid and the last key.
void	testScanIdx (uint totalKeys, uint nKeys, uint bufSize, boost::shared_array< FixedBuffer > inputBuffer, uint expectedNBitmaps, PBuffer expectedBitmaps, bool dynamicRootPageId, bool useDynamicKeys, bool includeRid, const boost::scoped_array< uint64_t > &vals)
	Performs an index search using the key values/directives passed in.
void	initEqualSearch (uint nKeys, uint nInputTuples, boost::scoped_array< uint64_t > &vals, char &lowerDirective, char &upperDirective, TupleAccessor &inputTupleAccessor, TupleData &inputTupleData, boost::shared_array< FixedBuffer > &inputBuffer, bool useDynamicKeys)
	Initializes input search key and directives for an equality search.
void	setSearchKey (char lowerDirective, char upperDirective, uint64_t lowerVal, uint64_t upperVal, PBuffer inputBuf, uint &offset, TupleAccessor &inputTupleAccessor, TupleData &inputTupleData)
void	initBitmapInput (BitmapInput &bmInput, uint nRows, InputData const &inputData)
void	initBitmapInput (BitmapInput &bmInput, uint nRows, LbmNumberStreamInput input)
void	generateBitmaps (uint nRows, LbmNumberStreamInput input, BitmapInput &bmInput)
void	generateBitmaps (uint nRows, uint start, uint skipRows, PBuffer pBuf, uint &bufSize, uint fullBufSize, uint &nBitmaps, bool includeKeys=false)
	Generate bitmaps to used in verifying result of bitmap index scan.
void	produceEntry (LbmEntry &lbmEntry, TupleAccessor &bitmapTupleAccessor, BitmapInput &bmInput)
void	produceEntry (LbmEntry &lbmEntry, TupleAccessor &bitmapTupleAccessor, PBuffer pBuf, uint &bufSize, uint &nBitmaps, bool includeKeys)
void	initValuesExecStream (uint idx, ValuesExecStreamParams &valuesParams, ExecStreamEmbryo &valuesStreamEmbryo, BitmapInput &bmInput)
void	initSorterExecStream (ExternalSortExecStreamParams &params, ExecStreamEmbryo &embryo, TupleDescriptor const &outputDesc, uint nKeys=1)
void	initNormalizerExecStream (LbmNormalizerExecStreamParams &params, ExecStreamEmbryo &embryo, uint nKeys)
uint	resultBitmapSize (uint start, uint end)
	Calculates size of result bitmap.
uint	resultBitmapSize (uint nRids)
void	initKeyBitmap (uint nRows, std::vector< int > const &repeatSeqValues)
	Initialize bitmaps with keys.
SharedExecStream	prepareSourceGraph (ExecStreamEmbryo &sourceStreamEmbryo)
	Defines and prepares a graph consisting of one source stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of one source stream and one transform stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, std::vector< ExecStreamEmbryo > &transforms)
	Defines and prepares a graph consisting of one source stream and one or multiple transform streams.
SharedExecStream	prepareConfluenceGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of two source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< ExecStreamEmbryo > &sourceStreamEmbryos, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of a list of source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< std::vector< ExecStreamEmbryo > > &sourceStreamEmbryosList, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of one or more source streams and one confluence stream.
SharedExecStream	prepareConfluenceTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< ExecStreamEmbryo > &interStreamEmbryos, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< std::vector< ExecStreamEmbryo > > &interStreamEmbryosList, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.
void	verifyOutput (ExecStream &stream, uint nRowsExpected, MockProducerExecStreamGenerator &verifier, bool stopEarly=false)
	Executes the prepared stream graph and verifies that its output matches that produced by a value generator.
void	verifyConstantOutput (ExecStream &stream, const TupleData &expectedTuple, uint nRowsExpected)
	Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.
void	verifyBufferedOutput (ExecStream &stream, TupleDescriptor outputTupleDesc, uint nRowsExpected, PBuffer expectedBuffer)
	Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.
void	resetExecStreamTest ()
	Reset stream graph so multiple iterations of a method can be called within a single testcase.
virtual void	tearDownExecStreamTest ()
	ExecStream-specific handler called from testCaseTearDown.
virtual SharedExecStreamGraph	newStreamGraph ()
	Creates a stream graph.
virtual SharedExecStreamGraphEmbryo	newStreamGraphEmbryo (SharedExecStreamGraph)
	Creates an embryo for a stream graph.
virtual ExecStreamScheduler *	newScheduler ()
	Creates a scheduler.
virtual ExecStreamGovernor *	newResourceGovernor (ExecStreamResourceKnobs const &knobSettings, ExecStreamResourceQuantity const &resourcesAvailable)
	Creates the resource governor.
void	snooze (uint nSeconds)
Static Protected Member Functions
static const std::string &	getTraceName ()
Protected Attributes
TupleAttributeDescriptor	attrDesc_char1
TupleAttributeDescriptor	attrDesc_nullableInt64
vector< boost::shared_ptr< BTreeDescriptor > >	bTreeClusters
	BTrees corresponding to the clusters.
vector< PageId >	savedBTreeClusterRootIds
	Saved root pageids of btrees corresponding to clusters; used to append to existing table and to read from them.
vector< boost::shared_ptr< BTreeDescriptor > >	bTreeBitmaps
	BTrees corresponding to the bitmaps.
vector< PageId >	savedBTreeBitmapRootIds
	Saved root pageids of btrees corresponding to bitmaps; used to append to existing table and to read from them.
StandardTypeDescriptorFactory	stdTypeFactory
TupleAttributeDescriptor	attrDesc_int64
TupleAttributeDescriptor	attrDesc_bitmap
uint	bitmapColSize
	Size of bitmap columns.
TupleDescriptor	bitmapTupleDesc
	Tuple descriptor, tupledata, and accessor for a bitmap segment: (rid, segment descriptor, bitmap segments).
TupleData	bitmapTupleData
TupleAccessor	bitmapTupleAccessor
TupleDescriptor	keyBitmapTupleDesc
	Tuple descriptor, data, and accessor for key-containting bitmaps (keys, srid, segment descriptor, bitmap segments).
TupleData	keyBitmapTupleData
TupleAccessor	keyBitmapTupleAccessor
boost::shared_array< FixedBuffer >	keyBitmapBuf
uint	keyBitmapBufSize
SharedExecStreamGraph	pGraph
SharedExecStreamGraphEmbryo	pGraphEmbryo
SharedExecStreamScheduler	pScheduler
SharedExecStreamGovernor	pResourceGovernor
SharedCacheAccessor	pCacheAccessor
SharedSegmentFactory	pSegmentFactory
SharedSegment	pLinearSegment
	Segment supporting linear page allocation.
SharedSegment	pRandomSegment
	(Optional) segment supporting random page allocation.
SharedSegment	pVersionedRandomSegment
	(Optional) segment supporting versioned random page allocation.
SharedSegment	pSnapshotRandomSegment
	(Optional) segment supporting snapshot random page allocation.
VictimPolicy	victimPolicy
	VictimPolicy to instantiate.
CacheParams	cacheParams
	Parameters for cache initialization.
SharedCache	pCache
	Cache instance being tested.
SharedRandomAccessDevice	pRandomAccessDevice
	The default cached device.
uint	nMemPages
	Size of cache in memory pages.
uint	nDiskPages
	Size of device in disk pages.
uint	cbPageFull
	Disk page size.
DeviceId	dataDeviceId
	Fixed ID to assign to data device.
TestSuite *	pTestSuite
	Boost test suite.
boost::shared_ptr< TestBase >	pTestObj
std::ofstream	traceStream
	Output file stream for tracing.
StrictMutex	traceMutex
	Protects traceStream.
std::string	testName
	Name of test.
TraceLevel	traceLevel
	Level at which to trace test execution.
FileStatsTarget	statsTarget
	Output for stats.
StatsTimer	statsTimer
	Timer for stats collection.
bool	traceStdout
	Copy trace output to stdout.
bool	traceFile
	Copy trace output to file.
TestCaseGroup	defaultTests
TestCaseGroup	extraTests
Static Protected Attributes
static const uint	DefaultCacheReservePercent = 5
static const uint	DefaultConcurrentStatements = 4
static bool	runAll
	Run all test cases, including the extra tests.
static std::string	runSingle
	Run only the test case of this name.

---

Detailed Description

Testcase for scanning a single bitmap index using equality search on all index keys.

Definition at line 55 of file LbmSearchTest.cpp.

---

Member Enumeration Documentation

enum CacheTestBase::VictimPolicy [protected, inherited]

The available victim policy implementations.

Enumerator:

victimTwoQ
victimLRU
victimRandom

Definition at line 44 of file CacheTestBase.h.

                      {
        victimTwoQ,
        victimLRU,
        victimRandom
    };

---

Constructor & Destructor Documentation

LbmSearchTest::LbmSearchTest

(

)

[inline, explicit]

Definition at line 236 of file LbmSearchTest.cpp.

References testMultipleRanges(), testScanOneLevel(), and testScanTwoLevel().

    {
        FENNEL_UNIT_TEST_CASE(LbmSearchTest, testScanOneLevel);
        FENNEL_UNIT_TEST_CASE(LbmSearchTest, testScanTwoLevel);
        FENNEL_UNIT_TEST_CASE(LbmSearchTest, testMultipleRanges);
    }

---

Member Function Documentation

void LbmSearchTest::initBTreeExecStreamParam	(	BTreeExecStreamParams &	param,
		shared_ptr< BTreeDescriptor >	pBTreeDesc
	)			[protected]

Initializes a BTreeExecStreamParam structure.

Definition at line 790 of file LbmSearchTest.cpp.

References initBTreeParam(), CacheTestBase::pCache, ExecStreamParams::pCacheAccessor, SegStorageTestBase::pSegmentFactory, and ExecStreamParams::scratchAccessor.

Referenced by loadTableAndIndex(), and testScanIdx().

{
    param.scratchAccessor = pSegmentFactory->newScratchSegment(pCache, 15);
    param.pCacheAccessor = pCache;
    initBTreeParam(param, pBTreeDesc);
}

void LbmSearchTest::initBTreeParam	(	BTreeParams &	param,
		shared_ptr< BTreeDescriptor >	pBTreeDesc
	)			[protected]

Initializes BTreeParams structure.

Definition at line 798 of file LbmSearchTest.cpp.

References BTreeParams::keyProj, BTreeParams::pageOwnerId, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, BTreeParams::pRootMap, BTreeParams::pSegment, BTreeParams::rootPageIdParamId, BTreeParams::segmentId, and BTreeParams::tupleDesc.

Referenced by initBTreeExecStreamParam(), and loadTableAndIndex().

{
    param.pSegment = pRandomSegment;
    param.pRootMap = 0;
    param.rootPageIdParamId = DynamicParamId(0);

    pBTreeDesc->segmentAccessor.pSegment = param.pSegment;
    pBTreeDesc->segmentAccessor.pCacheAccessor = pCache;
    pBTreeDesc->tupleDescriptor = param.tupleDesc;
    pBTreeDesc->keyProjection = param.keyProj;
    param.pageOwnerId = pBTreeDesc->pageOwnerId;
    param.segmentId = pBTreeDesc->segmentId;
}

void LbmSearchTest::initClusterScanDef	(	LcsRowScanBaseExecStreamParams &	generatorParams,
		struct LcsClusterScanDef &	clusterScanDef,
		uint	bTreeIndex
	)			[protected]

Initializes a cluster scan def structure for a LcsRowScanBase exec stream.

Definition at line 813 of file LbmSearchTest.cpp.

References bTreeClusters, BTreeParams::keyProj, LcsRowScanBaseExecStreamParams::lcsClusterScanDefs, BTreeParams::pageOwnerId, ExecStreamParams::pCacheAccessor, BTreeParams::pRootMap, BTreeParams::pSegment, BTreeParams::rootPageId, BTreeParams::rootPageIdParamId, BTreeParams::segmentId, and BTreeParams::tupleDesc.

Referenced by loadTableAndIndex().

{
    clusterScanDef.pSegment =
        bTreeClusters[bTreeIndex]->segmentAccessor.pSegment;
    clusterScanDef.pCacheAccessor =
        bTreeClusters[bTreeIndex]->segmentAccessor.pCacheAccessor;
    clusterScanDef.tupleDesc = bTreeClusters[bTreeIndex]->tupleDescriptor;
    clusterScanDef.keyProj = bTreeClusters[bTreeIndex]->keyProjection;
    clusterScanDef.rootPageId = bTreeClusters[bTreeIndex]->rootPageId;
    clusterScanDef.pageOwnerId = bTreeClusters[bTreeIndex]->pageOwnerId;
    clusterScanDef.segmentId = bTreeClusters[bTreeIndex]->segmentId;
    clusterScanDef.pRootMap = 0;
    clusterScanDef.rootPageIdParamId = DynamicParamId(0);
    rowScanParams.lcsClusterScanDefs.push_back(clusterScanDef);
}

void LbmSearchTest::initBTreeBitmapDesc	(	TupleDescriptor &	tupleDesc,
		TupleProjection &	keyProj,
		uint	nKeys
	)			[protected]

Initializes BTreeExecStreamParam corresponding to a bitmap index.

Parameters:

	tupleDesc	tuple descriptor corresponding to bitmap index
	keyProj	projection corresponding to the bitmap index keys; excludes start rid
	nKeys	number of keys in the bitmap index; excludes start rid from key count

Definition at line 832 of file LbmSearchTest.cpp.

References initBTreeTupleDesc(), BTreeParams::keyProj, and BTreeParams::tupleDesc.

Referenced by loadTableAndIndex(), and testScanIdx().

{
    initBTreeTupleDesc(tupleDesc, nKeys);

    // btree key consists of the key columns and the start rid
    for (uint j = 0; j < nKeys + 1; j++) {
        keyProj.push_back(j);
    }
}

void LbmSearchTest::initBTreeTupleDesc	(	TupleDescriptor &	tupleDesc,
		uint	nKeys
	)			[protected]

Initializes a tuple descriptor corresponding to a bitmap index.

Parameters:

	tupleDesc	tuple descriptor corresponding to bitmap index
	nKeys	number of keys in the bitmap index; excludes start rid from key count

Definition at line 843 of file LbmSearchTest.cpp.

References LbmExecStreamTestBase::attrDesc_int64, LbmExecStreamTestBase::bitmapTupleDesc, and BTreeParams::tupleDesc.

Referenced by initBTreeBitmapDesc(), and loadTableAndIndex().

{
    for (uint i = 0; i < nKeys; i++) {
        tupleDesc.push_back(attrDesc_int64);
    }
    // add on the rid and bitmaps
    tupleDesc.push_back(bitmapTupleDesc[0]);
    tupleDesc.push_back(bitmapTupleDesc[1]);
    tupleDesc.push_back(bitmapTupleDesc[2]);
}

void LbmSearchTest::loadTableAndIndex	(	uint	nRows,
		uint	nClusters,
		std::vector< int > const &	repeatSeqValues,
		bool	newRoot
	)			[protected]

Loads a table with nClusters clusters, 1 column per cluster, and nRows rows.

Each column has a repeating sequence of values based on the value in the repeatSeqValues vector. E.g., a repeating sequence of n will have values:

(0, 1, 2, ..., n-1, 0, 1, 2, ..., n-1, 0, 1, 2, ...).

Then a single bitmap index is created on all columns.

Parameters:

	nRows	number of rows to load
	nClusters	number of clusters to create
	repeatSeqValues	repeating sequence values for each column
	newRoot	if true, append to existing table

Definition at line 549 of file LbmSearchTest.cpp.

References LbmExecStreamTestBase::attrDesc_int64, BARRIER_RET_ANY_INPUT, bTreeBitmaps, bTreeClusters, LbmSplicerExecStreamParams::bTreeParams, LcsClusterScanDef::clusterTupleDesc, BTreeBuilder::createEmptyRoot(), LbmGeneratorExecStreamParams::createIndex, LbmSplicerExecStreamParams::createNewIndex, ExternalSortExecStreamParams::distinctness, DUP_ALLOW, ExternalSortExecStreamParams::earlyClose, ExternalSortExecStreamParams::estimatedNumRows, BTreeAccessBase::getRootPageId(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), initBTreeBitmapDesc(), initBTreeExecStreamParam(), initBTreeParam(), initBTreeTupleDesc(), initClusterScanDef(), LbmSplicerExecStreamParams::insertRowCountParamId, LbmGeneratorExecStreamParams::insertRowCountParamId, ExternalSortExecStreamParams::keyProj, BTreeParams::keyProj, MAXU, ExternalSortExecStream::newExternalSortExecStream(), MockProducerExecStreamParams::nRows, LcsRowScanBaseExecStreamParams::outputProj, DiffluenceExecStreamParams::outputTupleDesc, SingleOutputExecStreamParams::outputTupleDesc, CacheTestBase::pCache, MockProducerExecStreamParams::pGenerator, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), SegStorageTestBase::pSegmentFactory, ExternalSortExecStreamParams::pTempSegment, BarrierExecStreamParams::returnMode, BTreeParams::rootPageId, savedBTreeBitmapRootIds, savedBTreeClusterRootIds, ExternalSortExecStreamParams::storeFinalRun, BTreeParams::tupleDesc, ExecStreamUnitTestBase::verifyOutput(), and LbmSplicerExecStreamParams::writeRowCountParamId.

Referenced by testMultipleRanges(), and testScans().

{
    // 0. reset member fields.
    for (uint i = 0; i < bTreeClusters.size(); i++) {
        bTreeClusters[i]->segmentAccessor.reset();
    }
    for (uint i = 0; i < bTreeBitmaps.size(); i++) {
        bTreeBitmaps[i]->segmentAccessor.reset();
    }
    bTreeClusters.clear();
    bTreeBitmaps.clear();

    // 1. setup mock input stream

    MockProducerExecStreamParams mockParams;
    for (uint i = 0; i < nClusters; i++) {
        mockParams.outputTupleDesc.push_back(attrDesc_int64);
    }
    mockParams.nRows = nRows;

    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator col;
    assert(repeatSeqValues.size() == nClusters);
    for (uint i = 0; i < repeatSeqValues.size(); i++) {
        col =
            SharedInt64ColumnGenerator(
                new RepeatingSeqColumnGenerator(repeatSeqValues[i]));
        columnGenerators.push_back(col);
    }
    mockParams.pGenerator.reset(
        new CompositeExecStreamGenerator(columnGenerators));

    ExecStreamEmbryo mockStreamEmbryo;
    mockStreamEmbryo.init(new MockProducerExecStream(), mockParams);
    mockStreamEmbryo.getStream()->setName("MockProducerExecStream");

    // 2. setup splitter stream for cluster loads

    SplitterExecStreamParams splitterParams;
    ExecStreamEmbryo splitterStreamEmbryo;
    splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams);
    splitterStreamEmbryo.getStream()->setName("ClusterSplitterExecStream");

    // 3. setup loader streams

    vector<ExecStreamEmbryo> lcsAppendEmbryos;
    for (uint i = 0; i < nClusters; i++) {
        LcsClusterAppendExecStreamParams lcsAppendParams;
        boost::shared_ptr<BTreeDescriptor> pBTreeDesc =
            boost::shared_ptr<BTreeDescriptor> (new BTreeDescriptor());
        bTreeClusters.push_back(pBTreeDesc);

        // initialize the btree parameter portion of lcsAppendParams
        // BTree tuple desc has two columns (rid, clusterPageid)
        (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);
        (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);

        // BTree key only has one column which is the first column.
        (lcsAppendParams.keyProj).push_back(0);

        initBTreeExecStreamParam(lcsAppendParams, pBTreeDesc);

        // output two values (rows inserted, starting rid value)
        lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);
        lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);

        lcsAppendParams.inputProj.push_back(i);

        // create an empty page to start the btree

        if (newRoot) {
            BTreeBuilder builder(*pBTreeDesc, pRandomSegment);
            builder.createEmptyRoot();
            savedBTreeClusterRootIds.push_back(builder.getRootPageId());
        }
        lcsAppendParams.rootPageId = pBTreeDesc->rootPageId =
            savedBTreeClusterRootIds[i];

        // Now use the above initialized parameter

        ExecStreamEmbryo lcsAppendStreamEmbryo;
        lcsAppendStreamEmbryo.init(
            new LcsClusterAppendExecStream(), lcsAppendParams);
        std::ostringstream oss;
        oss << "LcsClusterAppendExecStream" << "#" << i;
        lcsAppendStreamEmbryo.getStream()->setName(oss.str());
        lcsAppendEmbryos.push_back(lcsAppendStreamEmbryo);
    }

    // 4. setup barrier stream for cluster loads

    BarrierExecStreamParams barrierParams;
    barrierParams.outputTupleDesc.push_back(attrDesc_int64);
    barrierParams.outputTupleDesc.push_back(attrDesc_int64);
    barrierParams.returnMode = BARRIER_RET_ANY_INPUT;

    ExecStreamEmbryo clusterBarrierStreamEmbryo;
    clusterBarrierStreamEmbryo.init(new BarrierExecStream(), barrierParams);
    clusterBarrierStreamEmbryo.getStream()->setName("ClusterBarrierExecStream");

    // create a DAG with the above, but without the final output sink
    prepareDAG(
        mockStreamEmbryo, splitterStreamEmbryo, lcsAppendEmbryos,
        clusterBarrierStreamEmbryo, false);

    // 5. setup splitter stream for create bitmaps

    splitterStreamEmbryo.init(
        new SplitterExecStream(), splitterParams);
    splitterStreamEmbryo.getStream()->setName("BitmapSplitterExecStream");

    // create streams for bitmap generator, sort, and bitmap splicer to
    // build an index on all columns

    std::vector<std::vector<ExecStreamEmbryo> > createBitmapStreamList;
        std::vector<ExecStreamEmbryo> createBitmapStream;

    // 6. setup generator

    LbmGeneratorExecStreamParams generatorParams;
    struct LcsClusterScanDef clusterScanDef;
    clusterScanDef.clusterTupleDesc.push_back(attrDesc_int64);

    for (uint j = 0; j < nClusters; j++) {
        initClusterScanDef(generatorParams, clusterScanDef, j);
    }

    TupleProjection proj;
    for (uint j = 0; j < nClusters; j++) {
        proj.push_back(j);
    }
    generatorParams.outputProj = proj;
    generatorParams.insertRowCountParamId = DynamicParamId(1);
    generatorParams.createIndex = false;

    boost::shared_ptr<BTreeDescriptor> pBTreeDesc =
        boost::shared_ptr<BTreeDescriptor> (new BTreeDescriptor());
    bTreeBitmaps.push_back(pBTreeDesc);

    // BTree tuple desc has the key columns + starting Rid + varbinary
    // field for bit segments/bit descriptors
    uint nKeys = nClusters;
    initBTreeTupleDesc(generatorParams.outputTupleDesc, nKeys);

    initBTreeBitmapDesc(
        generatorParams.tupleDesc, generatorParams.keyProj, nKeys);
    initBTreeExecStreamParam(generatorParams, pBTreeDesc);

    // create an empty page to start the btree

    if (newRoot) {
        BTreeBuilder builder(*pBTreeDesc, pRandomSegment);
        builder.createEmptyRoot();
        savedBTreeBitmapRootIds.push_back(builder.getRootPageId());
    }
    generatorParams.rootPageId = pBTreeDesc->rootPageId =
        savedBTreeBitmapRootIds[0];

    ExecStreamEmbryo generatorStreamEmbryo;
    generatorStreamEmbryo.init(
        new LbmGeneratorExecStream(), generatorParams);
    std::ostringstream oss;
    oss << "LbmGeneratorExecStream" << "#" << 0;
    generatorStreamEmbryo.getStream()->setName(oss.str());
    createBitmapStream.push_back(generatorStreamEmbryo);

    // 7. setup sorter

    ExternalSortExecStreamParams sortParams;
    initBTreeBitmapDesc(
        sortParams.outputTupleDesc, sortParams.keyProj, nKeys);
    sortParams.distinctness = DUP_ALLOW;
    sortParams.pTempSegment = pRandomSegment;
    sortParams.pCacheAccessor = pCache;
    sortParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache, 10);
    sortParams.storeFinalRun = false;
    sortParams.estimatedNumRows = MAXU;
    sortParams.earlyClose = false;

    ExecStreamEmbryo sortStreamEmbryo;
    sortStreamEmbryo.init(
        ExternalSortExecStream::newExternalSortExecStream(), sortParams);
    sortStreamEmbryo.getStream()->setName("ExternalSortExecStream");
    std::ostringstream oss2;
    oss2 << "ExternalSortExecStream" << "#" << 0;
    sortStreamEmbryo.getStream()->setName(oss2.str());
    createBitmapStream.push_back(sortStreamEmbryo);

    // 8. setup splicer

    LbmSplicerExecStreamParams splicerParams;
    splicerParams.createNewIndex = false;
    splicerParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache, 15);
    splicerParams.pCacheAccessor = pCache;
    BTreeParams bTreeParams;
    initBTreeBitmapDesc(
        bTreeParams.tupleDesc, bTreeParams.keyProj, nKeys);
    initBTreeParam(bTreeParams, pBTreeDesc);
    bTreeParams.rootPageId = pBTreeDesc->rootPageId;
    splicerParams.bTreeParams.push_back(bTreeParams);
    splicerParams.insertRowCountParamId = DynamicParamId(1);
    splicerParams.writeRowCountParamId = DynamicParamId(0);
    splicerParams.outputTupleDesc.push_back(attrDesc_int64);

    ExecStreamEmbryo splicerStreamEmbryo;
    splicerStreamEmbryo.init(new LbmSplicerExecStream(), splicerParams);
    std::ostringstream oss3;
    oss3 << "LbmSplicerExecStream" << "#" << 0;
    splicerStreamEmbryo.getStream()->setName(oss3.str());
    createBitmapStream.push_back(splicerStreamEmbryo);

    // connect the sorter and splicer to generator and then add this
    // newly connected stream to the list of create bitmap stream embryos
    createBitmapStreamList.push_back(createBitmapStream);

    // 9. setup barrier stream for create bitmaps

    barrierParams.outputTupleDesc.clear();
    barrierParams.outputTupleDesc.push_back(attrDesc_int64);

    ExecStreamEmbryo barrierStreamEmbryo;
    barrierStreamEmbryo.init(
        new BarrierExecStream(), barrierParams);
    barrierStreamEmbryo.getStream()->setName("BitmapBarrierExecStream");

    // create the bitmap stream graph, with the load stream graph from
    // above as the source
    SharedExecStream pOutputStream = prepareDAG(
        clusterBarrierStreamEmbryo, splitterStreamEmbryo,
        createBitmapStreamList, barrierStreamEmbryo, true, false);

    // set up a generator which can produce the expected output
    RampExecStreamGenerator expectedResultGenerator(mockParams.nRows);

    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void LbmSearchTest::testScanFullKey	(	uint	nRows,
		uint	nKeys,
		std::vector< int > const &	repeatSeqValues,
		bool	useDynamicKeys,
		bool	includeRid
	)			[protected]

Tests equality scan on the table created in loadTableAndIndex, using the entire index key (minus the rid).

Parameters:

	nRows	total number of rows in the table
	nKeys	number of keys in the index (excluding startrid)
	repeatSeqValues	initial repeating sequence values for each column
	useDynamicKeys	if true, pass search keys through dynamic parameters
	includeRid	if true, include rid >= 0 in the search

Definition at line 389 of file LbmSearchTest.cpp.

References FixedBuffer, LbmExecStreamTestBase::generateBitmaps(), TupleAccessor::getCurrentByteCount(), initEqualSearch(), TupleAccessor::marshal(), and testScanIdx().

Referenced by testMultipleRanges(), and testScans().

{
    // search for key0 = <val0>, key1 = <val1>, ..., key(n-1) = <val(n-1)>
    uint nInputTuples = 1;
    boost::scoped_array<uint64_t> vals;
    char lowerDirective;
    char upperDirective;
    TupleAccessor inputTupleAccessor;
    TupleData inputTupleData;
    boost::shared_array<FixedBuffer> inputBuffer;

    initEqualSearch(
        nKeys, nInputTuples, vals, lowerDirective, upperDirective,
        inputTupleAccessor, inputTupleData, inputBuffer, useDynamicKeys);

    // do a search on each possible key combo
    uint skipRows = 1;
    for (uint i = 0; i < nKeys; i++) {
        skipRows *= repeatSeqValues[i];
    }
    for (uint i = 0; i < skipRows; i++) {
        // generate input keys for search
        for (uint j = 0; j < nKeys; j++) {
            vals[j] = i % repeatSeqValues[j];
        }
        inputTupleAccessor.marshal(inputTupleData, inputBuffer.get());

        // generate expected bitmap result
        boost::scoped_array<FixedBuffer> expectedBitmaps;
        uint bufferSize = (nRows / skipRows + 1) * 16;
        expectedBitmaps.reset(new FixedBuffer[bufferSize]);
        uint expectedNBitmaps = 0;
        uint expectedBufSize = 0;
        generateBitmaps(
            nRows, i, skipRows, expectedBitmaps.get(), expectedBufSize,
            bufferSize, expectedNBitmaps);

        testScanIdx(
            nKeys, nKeys, inputTupleAccessor.getCurrentByteCount(),
            inputBuffer, expectedNBitmaps, expectedBitmaps.get(), false,
            useDynamicKeys, includeRid, vals);
    }
}

void LbmSearchTest::testScanPartialKey	(	uint	nRows,
		uint	nKeys,
		std::vector< int > const &	repeatSeqValues
	)			[protected]

Tests equality scan on the table created in loadTableAndIndex, using the all keys except the rid and the last key.

Parameters:

	nRows	total number of rows in the table
	nKeys	number of keys in the index (excluding startrid)
	repeatSeqValues	initial repeating sequence values for each column

Definition at line 435 of file LbmSearchTest.cpp.

References FixedBuffer, LbmExecStreamTestBase::generateBitmaps(), TupleAccessor::getCurrentByteCount(), initEqualSearch(), TupleAccessor::marshal(), and testScanIdx().

Referenced by testScans().

{
    // search for key0 = 0, key1 = 0, ..., key(n-2) = 0
    uint nInputTuples = 1;
    boost::scoped_array<uint64_t> vals;
    char lowerDirective;
    char upperDirective;
    TupleAccessor inputTupleAccessor;
    TupleData inputTupleData;
    boost::shared_array<FixedBuffer> inputBuffer;

    initEqualSearch(
        nKeys - 1, nInputTuples, vals, lowerDirective, upperDirective,
        inputTupleAccessor, inputTupleData, inputBuffer, false);

    // generate input keys for search
    for (uint j = 0; j < nKeys - 1; j++) {
        vals[j] = 0;
    }
    inputTupleAccessor.marshal(inputTupleData, inputBuffer.get());

    // Generate one set of bitmaps for each key combo that can be combined
    // with the partial key. E.g., if there are 3 keys, generate the
    // bitmaps that would be obtained from searching for (0, 0, 0), (0, 0, 1),
    // ..., (0, 0, repeatSeqValues[nKeys-1] - 1)

    uint skipRows = 1;
    for (uint i = 0; i < nKeys - 1; i++) {
        skipRows *= repeatSeqValues[i];
    }
    boost::scoped_array<FixedBuffer> expectedBitmaps;
    uint bufferSize = (nRows / skipRows / 8 + 1)
        * 12 * repeatSeqValues[nKeys - 1];
    expectedBitmaps.reset(new FixedBuffer[bufferSize]);
    PBuffer bitmapBuf = expectedBitmaps.get();
    uint expectedNBitmaps = 0;
    uint curBufSize = 0;

    for (uint i = 0; i < repeatSeqValues[nKeys - 1]; i++) {
        uint start;
        if (i == 0) {
            start = 0;
        } else {
            // look for the first rid where the last key is equal to "i" and
            // the preceeding keys are all 0
            for (start = i; start < nRows;
                 start += repeatSeqValues[nKeys - 1])
            {
                uint j;
                for (j = 0; j < nKeys - 1; j++) {
                    if (start % repeatSeqValues[j] != 0) {
                        break;
                    }
                }
                if (j == nKeys - 1) {
                    break;
                }
            }
            if (start >= nRows) {
                continue;
            }
        }
        generateBitmaps(
            nRows, start, skipRows * repeatSeqValues[nKeys - 1],
            bitmapBuf, curBufSize, bufferSize, expectedNBitmaps);
    }
    testScanIdx(
        nKeys, nKeys - 1, inputTupleAccessor.getCurrentByteCount(),
        inputBuffer, expectedNBitmaps, bitmapBuf, false, false, false, vals);
}

void LbmSearchTest::testScanIdx	(	uint	totalKeys,
		uint	nKeys,
		uint	bufSize,
		boost::shared_array< FixedBuffer >	inputBuffer,
		uint	expectedNBitmaps,
		PBuffer	expectedBitmaps,
		bool	dynamicRootPageId,
		bool	useDynamicKeys,
		bool	includeRid,
		const boost::scoped_array< uint64_t > &	vals
	)			[protected]

Performs an index search using the key values/directives passed in.

Parameters:

	totalKeys	total number of keys in the index (excluding startrid)
	nKeys	number of keys to use in index search; always excludes startrid
	bufSize	size of input buffer containing search keys/directive
	inputBuffer	buffer containing search key/directive tuples to be passed into the index scan
	expectedNBitmaps	expected number of bitmaps in result
	expectedBitmaps	buffer containing expected bitmap result
	dynamicRootPageId	if true, pass in the btree rootPageId as a dynamic parameter
	useDynamicKeys	if true, pass in search key values using dynamic parameters
	includeRid	include rid in search
	vals	search key values

Definition at line 882 of file LbmSearchTest.cpp.

References attrDesc_char1, LbmExecStreamTestBase::attrDesc_int64, attrDesc_nullableInt64, LbmExecStreamTestBase::bitmapTupleAccessor, LbmExecStreamTestBase::bitmapTupleDesc, bTreeBitmaps, ValuesExecStreamParams::bufSize, TupleDatum::cbData, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), initBTreeBitmapDesc(), initBTreeExecStreamParam(), NULL_PAGE_ID, SingleOutputExecStreamParams::outputTupleDesc, TupleDatum::pData, ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::prepareTransformGraph(), ValuesExecStreamParams::pTupleBuffer, ExecStreamUnitTestBase::resetExecStreamTest(), LbmSearchExecStreamParams::rowLimitParamId, savedBTreeBitmapRootIds, TupleAccessor::setCurrentTupleBuf(), LbmSearchExecStreamParams::startRidParamId, and ExecStreamUnitTestBase::verifyBufferedOutput().

Referenced by testMultipleRanges(), testScanFullKey(), and testScanPartialKey().

{
    resetExecStreamTest();

    // setup input into index scan; values stream will read tuples from
    // inputBuffer

    ValuesExecStreamParams valuesParams;
    for (uint i = 0; i < 2; i++) {
        valuesParams.outputTupleDesc.push_back(attrDesc_char1);
        for (uint j = 0; j < nKeys; j++) {
            valuesParams.outputTupleDesc.push_back(attrDesc_nullableInt64);
        }
    }
    valuesParams.pTupleBuffer = inputBuffer;
    valuesParams.bufSize = bufSize;

    ExecStreamEmbryo valuesStreamEmbryo;
    valuesStreamEmbryo.init(new ValuesExecStream(), valuesParams);
    valuesStreamEmbryo.getStream()->setName("ValuesExecStream");

    // setup index scan stream

    LbmSearchExecStreamParams indexScanParams;

    // initialize parameters specific to indexScan
    indexScanParams.rowLimitParamId = DynamicParamId(0);
    if (includeRid) {
        indexScanParams.startRidParamId = DynamicParamId(1);
        SharedDynamicParamManager pDynamicParamManager =
            pGraph->getDynamicParamManager();
        pDynamicParamManager->createParam(DynamicParamId(1), attrDesc_int64);
        TupleDatum ridDatum;
        LcsRid rid = LcsRid(0);
        ridDatum.pData = (PConstBuffer) &rid;
        ridDatum.cbData = sizeof(LcsRid);
        pDynamicParamManager->writeParam(DynamicParamId(1), ridDatum);
    } else {
        indexScanParams.startRidParamId = DynamicParamId(0);
    }

    // initialize parameters for btree read
    initBTreeBitmapDesc(
        indexScanParams.tupleDesc, indexScanParams.keyProj, totalKeys);
    initBTreeExecStreamParam(indexScanParams, bTreeBitmaps[0]);
    bTreeBitmaps[0]->rootPageId = savedBTreeBitmapRootIds[0];

    if (!dynamicRootPageId) {
        indexScanParams.rootPageId = savedBTreeBitmapRootIds[0];
    } else {
        indexScanParams.rootPageId = NULL_PAGE_ID;
        indexScanParams.rootPageIdParamId = DynamicParamId(2);
        SharedDynamicParamManager pDynamicParamManager =
            pGraph->getDynamicParamManager();
        pDynamicParamManager->createParam(DynamicParamId(2), attrDesc_int64);
        TupleDatum rootPageIdDatum;
        rootPageIdDatum.pData = (PConstBuffer) &(savedBTreeBitmapRootIds[0]);
        rootPageIdDatum.cbData = sizeof(PageId);
        pDynamicParamManager->writeParam(DynamicParamId(2), rootPageIdDatum);
    }

    TupleProjection outputProj;
    for (uint i = totalKeys; i < totalKeys + 3; i++) {
        outputProj.push_back(i);
    }
    indexScanParams.outputProj = outputProj;

    // initialize parameters for btree search
    indexScanParams.outerJoin = false;
    TupleProjection inputKeyProj;
    for (uint i = 0; i < 2; i++) {
        for (uint j = 0; j < nKeys; j++) {
            inputKeyProj.push_back(i * (nKeys + 1) + j + 1);
        }
    }
    indexScanParams.inputKeyProj = inputKeyProj;
    indexScanParams.inputDirectiveProj.push_back(0);
    indexScanParams.inputDirectiveProj.push_back(nKeys + 1);

    // output is bitmap btree tuple without the key values, but with the rid
    indexScanParams.outputTupleDesc = bitmapTupleDesc;

    if (useDynamicKeys) {
        SharedDynamicParamManager pDynamicParamManager =
            pGraph->getDynamicParamManager();
        for (uint i = 3; i < nKeys * 2 + 3; i++) {
            indexScanParams.searchKeyParams.push_back(
                BTreeSearchKeyParameter(
                    DynamicParamId(i),
                    i - 3));
            pDynamicParamManager->createParam(
                DynamicParamId(i), attrDesc_int64);
            TupleDatum keyValDatum;
            keyValDatum.pData = (PConstBuffer) &(vals[(i - 3) % nKeys]);
            keyValDatum.cbData = sizeof(uint64_t);
            pDynamicParamManager->writeParam(DynamicParamId(i), keyValDatum);
        }
    }

    ExecStreamEmbryo indexScanStreamEmbryo;
    indexScanStreamEmbryo.init(new LbmSearchExecStream(), indexScanParams);
    indexScanStreamEmbryo.getStream()->setName("IndexScanStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        valuesStreamEmbryo, indexScanStreamEmbryo);

    bitmapTupleAccessor.setCurrentTupleBuf(expectedBitmaps);
    verifyBufferedOutput(
        *pOutputStream, bitmapTupleDesc, expectedNBitmaps, expectedBitmaps);
}

void LbmSearchTest::initEqualSearch	(	uint	nKeys,
		uint	nInputTuples,
		boost::scoped_array< uint64_t > &	vals,
		char &	lowerDirective,
		char &	upperDirective,
		TupleAccessor &	inputTupleAccessor,
		TupleData &	inputTupleData,
		boost::shared_array< FixedBuffer > &	inputBuffer,
		bool	useDynamicKeys
	)			[protected]

Initializes input search key and directives for an equality search.

Parameters:

	nKeys	number of keys to search on
	nInputTuples	number of search ranges to create
	vals	values to search on
	lowerDirective	lower bound search directive
	upperDirective	upper bound search directive
	inputTupleAccessor	accessor to marshal/unmarshal search key
	inputTupleData	tupledata storing search key
	inputBuffer	buffer storing search key
	useDynamicKeys	if true, search key values are passed to the search stream using dynamic parameters

Definition at line 507 of file LbmSearchTest.cpp.

References attrDesc_char1, attrDesc_nullableInt64, TupleAccessor::compute(), TupleData::compute(), FixedBuffer, and TupleAccessor::getMaxByteCount().

Referenced by testScanFullKey(), and testScanPartialKey().

{
    TupleDescriptor inputTupleDesc;
    for (uint i = 0; i < 2; i++) {
        inputTupleDesc.push_back(attrDesc_char1);
        for (uint j = 0; j < nKeys; j++) {
            inputTupleDesc.push_back(attrDesc_nullableInt64);
        }
    }

    inputTupleData.compute(inputTupleDesc);

    vals.reset(new uint64_t[nKeys]);
    lowerDirective = '[';
    inputTupleData[0].pData = (PConstBuffer) &lowerDirective;
    upperDirective = ']';
    inputTupleData[nKeys + 1].pData = (PConstBuffer) &upperDirective;
    for (uint i = 0; i < nKeys; i++) {
        // If keys are being passed through dynamic parameters, set them to
        // NULL in the input row
        if (useDynamicKeys) {
            inputTupleData[i + 1].pData = NULL;
            inputTupleData[i + 1].cbData = 0;
            inputTupleData[nKeys + 1 + i + 1].pData = NULL;
            inputTupleData[nKeys + 1 + i + 1].cbData = 0;
        } else {
            inputTupleData[i + 1].pData = (PConstBuffer) &vals[i];
            inputTupleData[nKeys + 1 + i + 1].pData = (PConstBuffer) &vals[i];
        }
    }

    inputTupleAccessor.compute(inputTupleDesc);

    inputBuffer.reset(
        new FixedBuffer[nInputTuples * inputTupleAccessor.getMaxByteCount()]);
}

void LbmSearchTest::setSearchKey	(	char	lowerDirective,
		char	upperDirective,
		uint64_t	lowerVal,
		uint64_t	upperVal,
		PBuffer	inputBuf,
		uint &	offset,
		TupleAccessor &	inputTupleAccessor,
		TupleData &	inputTupleData
	)			[protected]

Definition at line 372 of file LbmSearchTest.cpp.

References TupleAccessor::getCurrentByteCount(), and TupleAccessor::marshal().

Referenced by testMultipleRanges().

{
    inputTupleData[0].pData = (PConstBuffer) &lowerDirective;
    inputTupleData[2].pData = (PConstBuffer) &upperDirective;
    if (lowerDirective != '-') {
        inputTupleData[1].pData = (PConstBuffer) &lowerVal;
    }
    if (upperDirective != '+') {
        inputTupleData[3].pData = (PConstBuffer) &upperVal;
    }
    inputTupleAccessor.marshal(inputTupleData, inputBuf + offset);
    offset += inputTupleAccessor.getCurrentByteCount();
}

void LbmSearchTest::testCaseSetUp

(

)

[virtual]

Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.

Default is no-op.

Reimplemented from LbmExecStreamTestBase.

Definition at line 855 of file LbmSearchTest.cpp.

References attrDesc_char1, attrDesc_nullableInt64, StandardTypeDescriptorFactory::newDataType(), STANDARD_TYPE_CHAR, STANDARD_TYPE_INT_64, LbmExecStreamTestBase::stdTypeFactory, and LbmExecStreamTestBase::testCaseSetUp().

{
    LbmExecStreamTestBase::testCaseSetUp();

    attrDesc_char1 = TupleAttributeDescriptor(
        stdTypeFactory.newDataType(STANDARD_TYPE_CHAR), false, 1);
    attrDesc_nullableInt64 = TupleAttributeDescriptor(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64),
        true, sizeof(uint64_t));
}

void LbmSearchTest::testCaseTearDown

(

)

[virtual]

Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.

Default is no-op.

Reimplemented from ExecStreamTestBase.

Definition at line 866 of file LbmSearchTest.cpp.

References bTreeBitmaps, bTreeClusters, savedBTreeBitmapRootIds, savedBTreeClusterRootIds, and ExecStreamTestBase::testCaseTearDown().

{
    for (uint i = 0; i < bTreeClusters.size(); i++) {
        bTreeClusters[i]->segmentAccessor.reset();
    }
    for (uint i = 0; i < bTreeBitmaps.size(); i++) {
        bTreeBitmaps[i]->segmentAccessor.reset();
    }
    bTreeClusters.clear();
    bTreeBitmaps.clear();
    savedBTreeClusterRootIds.clear();
    savedBTreeBitmapRootIds.clear();

    LbmExecStreamTestBase::testCaseTearDown();
}

void LbmSearchTest::testScans

(

uint

nRows

)

Definition at line 264 of file LbmSearchTest.cpp.

References loadTableAndIndex(), testScanFullKey(), and testScanPartialKey().

Referenced by testScanOneLevel(), and testScanTwoLevel().

{
    uint nClusters = 3;
    std::vector<int> repeatSeqValues;

    // load the data
    repeatSeqValues.push_back(1);
    repeatSeqValues.push_back(5);
    repeatSeqValues.push_back(9);
    loadTableAndIndex(nRows, nClusters, repeatSeqValues, true);

    // Scan on all keys, passing the search keys through the input stream.
    // Then do the same, passing the keys via dynamic parameters.  Then,
    // finally, do the search, including a rid search.
    testScanFullKey(nRows, nClusters, repeatSeqValues, false, false);
    testScanFullKey(nRows, nClusters, repeatSeqValues, true, false);
    testScanFullKey(nRows, nClusters, repeatSeqValues, false, true);

    // scan on (nClusters - 1) keys
    testScanPartialKey(nRows, nClusters, repeatSeqValues);
}

void LbmSearchTest::testScanOneLevel

(

)

Definition at line 252 of file LbmSearchTest.cpp.

References testScans().

Referenced by LbmSearchTest().

{
    // single level btree
    testScans(100);
}

void LbmSearchTest::testScanTwoLevel

(

)

Definition at line 258 of file LbmSearchTest.cpp.

References testScans().

Referenced by LbmSearchTest().

{
    // with a 3-key index, 2000 rows will generate a 2-level btree
    testScans(2000);
}

void LbmSearchTest::testMultipleRanges

(

)

Definition at line 286 of file LbmSearchTest.cpp.

References attrDesc_char1, attrDesc_nullableInt64, TupleAccessor::compute(), FixedBuffer, LbmExecStreamTestBase::generateBitmaps(), TupleAccessor::getMaxByteCount(), loadTableAndIndex(), ExecStreamUnitTestBase::resetExecStreamTest(), setSearchKey(), testScanFullKey(), and testScanIdx().

Referenced by LbmSearchTest().

{
    uint nRows = 20000;
    uint nClusters = 1;
    std::vector<int> repeatSeqValues;

    // load a table with a single index on a single column
    repeatSeqValues.push_back(100);
    loadTableAndIndex(nRows, nClusters, repeatSeqValues, true);

    // scan on all keys, just to make sure all key values really are there
    testScanFullKey(nRows, nClusters, repeatSeqValues, false, false);

    resetExecStreamTest();

    // Setup the following search keys.  Note that these keys weren't randomly
    // selected.  Some of them correspond to boundary conditions.
    // 1. key < 8
    // 2. key > 10 && key <= 17
    // 3. key >= 44 and key < 60
    // 4. key > 71

    TupleDescriptor inputTupleDesc;
    for (uint i = 0; i < 2; i++) {
        inputTupleDesc.push_back(attrDesc_char1);
        inputTupleDesc.push_back(attrDesc_nullableInt64);
    }
    TupleData inputTupleData(inputTupleDesc);
    TupleAccessor inputTupleAccessor;
    inputTupleAccessor.compute(inputTupleDesc);

    uint nInputTuples = 4;
    boost::shared_array<FixedBuffer> inputBuffer;
    inputBuffer.reset(
        new FixedBuffer[nInputTuples * inputTupleAccessor.getMaxByteCount()]);
    PBuffer inputBuf = inputBuffer.get();
    uint offset = 0;

    setSearchKey(
        '-', ')', 0, 8, inputBuf, offset, inputTupleAccessor, inputTupleData);
    setSearchKey(
        '(', ']', 10, 17, inputBuf, offset, inputTupleAccessor,
        inputTupleData);
    setSearchKey(
        '[', ')', 44, 60, inputBuf, offset, inputTupleAccessor,
        inputTupleData);
    setSearchKey(
        '(', '+', 71, 0, inputBuf, offset, inputTupleAccessor,
        inputTupleData);

    // setup the expected bitmap result values
    boost::scoped_array<FixedBuffer> expectedBitmaps;
    uint bufferSize = ((nRows / repeatSeqValues[0] / 8 + 1) * 60) * 24;
    expectedBitmaps.reset(new FixedBuffer[bufferSize]);
    PBuffer bitmapBuf = expectedBitmaps.get();
    uint expectedNBitmaps = 0;
    uint expectedBufSize = 0;
    // for each range, generate the bitmap values for each key in the desired
    // range
    for (uint i = 0; i < 8; i++) {
        generateBitmaps(
            nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize,
            bufferSize, expectedNBitmaps);
    }
    for (uint i = 11; i <= 17; i++) {
        generateBitmaps(
            nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize,
            bufferSize, expectedNBitmaps);
    }
    for (uint i = 44; i < 60; i++) {
        generateBitmaps(
            nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize,
            bufferSize, expectedNBitmaps);
    }
    for (uint i = 72; i < repeatSeqValues[0]; i++) {
        generateBitmaps(
            nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize,
            bufferSize, expectedNBitmaps);
    }

    boost::scoped_array<uint64_t> vals;
    testScanIdx(
        nClusters, nClusters, offset, inputBuffer, expectedNBitmaps,
        bitmapBuf, true, false, false, vals);
}

static const std::string& LbmExecStreamTestBase::getTraceName

(

)

[inline, static, protected, inherited]

Definition at line 300 of file LbmExecStreamTestBase.h.

References traceName.

Referenced by LbmExecStreamTestBase::generateBitmaps().

    {
        return traceName;
    }

void LbmExecStreamTestBase::initBitmapInput	(	BitmapInput &	bmInput,
		uint	nRows,
		InputData const &	inputData
	)			[protected, inherited]

Definition at line 27 of file LbmExecStreamTestBase.cpp.

References NumberStream::BIG_NUMBER, InputData::bitmapSize, LbmNumberStreamInput::bitmapSize, opaqueToInt(), LbmNumberStreamInput::pStream, InputData::skipRows, and InputData::startRid.

Referenced by LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmUnionExecStreamTest::testUnion().

{
    LbmNumberStreamInput input;
    SharedNumberStream pNumberStream(
        new SkipNumberStream(
            opaqueToInt(inputData.startRid),
            NumberStream::BIG_NUMBER, inputData.skipRows));
    input.pStream = pNumberStream;
    input.bitmapSize = inputData.bitmapSize;

    initBitmapInput(bmInput, nRows, input);
}

void LbmExecStreamTestBase::initBitmapInput	(	BitmapInput &	bmInput,
		uint	nRows,
		LbmNumberStreamInput	input
	)			[protected, inherited]

Definition at line 41 of file LbmExecStreamTestBase.cpp.

References BitmapInput::bufArray, BitmapInput::currBufSize, FixedBuffer, BitmapInput::fullBufSize, LbmExecStreamTestBase::generateBitmaps(), BitmapInput::nBitmaps, and LbmNumberStreamInput::pStream.

{
    bmInput.fullBufSize = input.pStream->getMaxRowCount(nRows) * 16;
    bmInput.bufArray.reset(new FixedBuffer[bmInput.fullBufSize]);
    bmInput.nBitmaps = 0;
    bmInput.currBufSize = 0;
    generateBitmaps(nRows, input, bmInput);
}

void LbmExecStreamTestBase::generateBitmaps	(	uint	nRows,
		LbmNumberStreamInput	input,
		BitmapInput &	bmInput
	)			[protected, inherited]

Definition at line 51 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::bitmapColSize, LbmNumberStreamInput::bitmapSize, LbmExecStreamTestBase::bitmapTupleAccessor, LbmExecStreamTestBase::bitmapTupleData, LbmExecStreamTestBase::bitmapTupleDesc, BitmapInput::currBufSize, FixedBuffer, BitmapInput::fullBufSize, LbmEntry::getScratchBufferSize(), TestBase::getSourceTraceLevel(), LbmExecStreamTestBase::getTraceName(), LbmEntry::init(), opaqueToInt(), LbmExecStreamTestBase::produceEntry(), LbmNumberStreamInput::pStream, LbmEntry::setEntryTuple(), LbmEntry::setRID(), and TRACE_FINER.

Referenced by LbmExecStreamTestBase::initBitmapInput(), LbmExecStreamTestBase::initKeyBitmap(), testMultipleRanges(), testScanFullKey(), and testScanPartialKey().

{
    LbmEntry lbmEntry;
    boost::scoped_array<FixedBuffer> entryBuf;
    LcsRid rid = LcsRid(input.pStream->getNext());

    // setup an LbmEntry with the initial rid value
    uint scratchBufSize = LbmEntry::getScratchBufferSize(bitmapColSize);
    entryBuf.reset(new FixedBuffer[scratchBufSize]);
    lbmEntry.init(entryBuf.get(), NULL, scratchBufSize, bitmapTupleDesc);
    bitmapTupleData[0].pData = (PConstBuffer) &rid;
    lbmEntry.setEntryTuple(bitmapTupleData);
    TraceLevel level = getSourceTraceLevel(getTraceName());
    if (level <= TRACE_FINER) {
        std::cout << "Set root: " << rid << std::endl;
    }

    // add on the remaining rids
    while (input.pStream->hasNext()) {
        rid = LcsRid(input.pStream->getNext());
        if (rid >= LcsRid(nRows)) {
            break;
        }
        if (level <= TRACE_FINER) {
            std::cout << "Set value: " << rid << std::endl;
        }
        if ((rid > LcsRid(0) &&
                opaqueToInt(rid % (input.bitmapSize*8)) == 0) ||
            !lbmEntry.setRID(LcsRid(rid)))
        {
            // either hit desired number of rids per bitmap segment or
            // exhausted buffer space, so write the tuple to the output
            // buffer and reset LbmEntry
            produceEntry(lbmEntry, bitmapTupleAccessor, bmInput);
            lbmEntry.setEntryTuple(bitmapTupleData);
        }
    }
    // write out the last LbmEntry
    produceEntry(lbmEntry, bitmapTupleAccessor, bmInput);

    assert(bmInput.currBufSize <= bmInput.fullBufSize);
}

void LbmExecStreamTestBase::generateBitmaps	(	uint	nRows,
		uint	start,
		uint	skipRows,
		PBuffer	pBuf,
		uint &	bufSize,
		uint	fullBufSize,
		uint &	nBitmaps,
		bool	includeKeys = false
	)			[protected, inherited]

Generate bitmaps to used in verifying result of bitmap index scan.

Parameters:

	nRows	number of rows in index
	start	initial rid value
	skipRows	generate rids every "skipRows" rows; i.e., if skipRows == 1, there are no gaps in the rids
	pBuf	buffer where bitmap segment tuples will be marshalled
	bufSize	amount of space currently used within pBuf
	fullBufSize	size of pBuf
	nBitmaps	returns number of bitmaps generated
	includeKeys	if true, include the keys in the generated bitmap entry

Definition at line 163 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::bitmapColSize, LbmExecStreamTestBase::bitmapTupleAccessor, LbmExecStreamTestBase::bitmapTupleData, LbmExecStreamTestBase::bitmapTupleDesc, FixedBuffer, LbmEntry::getScratchBufferSize(), LbmEntry::init(), LbmExecStreamTestBase::produceEntry(), LbmEntry::setEntryTuple(), and LbmEntry::setRID().

{
    LbmEntry lbmEntry;
    boost::scoped_array<FixedBuffer> entryBuf;
    LcsRid rid = LcsRid(start);

    // setup an LbmEntry with the initial rid value
    uint scratchBufSize = LbmEntry::getScratchBufferSize(bitmapColSize);
    entryBuf.reset(new FixedBuffer[scratchBufSize]);
    lbmEntry.init(entryBuf.get(), NULL, scratchBufSize, bitmapTupleDesc);
    bitmapTupleData[0].pData = (PConstBuffer) &rid;
    lbmEntry.setEntryTuple(bitmapTupleData);

    // add on the remaining rids
    for (rid = LcsRid(start + skipRows); rid < LcsRid(nRows); rid += skipRows) {
        if (!lbmEntry.setRID(LcsRid(rid))) {
            // exhausted buffer space, so write the tuple to the output
            // buffer and reset LbmEntry
            produceEntry(
                lbmEntry, bitmapTupleAccessor,
                pBuf, bufSize, nBitmaps, includeKeys);
            lbmEntry.setEntryTuple(bitmapTupleData);
        }
    }
    // write out the last LbmEntry
    produceEntry(
        lbmEntry, bitmapTupleAccessor, pBuf, bufSize, nBitmaps, includeKeys);

    assert(bufSize <= fullBufSize);
}

void LbmExecStreamTestBase::produceEntry	(	LbmEntry &	lbmEntry,
		TupleAccessor &	bitmapTupleAccessor,
		BitmapInput &	bmInput
	)			[protected, inherited]

Definition at line 95 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::bitmapTupleAccessor, BitmapInput::bufArray, BitmapInput::currBufSize, TupleAccessor::getCurrentByteCount(), TupleAccessor::marshal(), BitmapInput::nBitmaps, and LbmEntry::produceEntryTuple().

Referenced by LbmExecStreamTestBase::generateBitmaps().

{
    TupleData bitmapTuple = lbmEntry.produceEntryTuple();
    bitmapTupleAccessor.marshal(
        bitmapTuple, bmInput.bufArray.get() + bmInput.currBufSize);
    bmInput.currBufSize += bitmapTupleAccessor.getCurrentByteCount();
    ++bmInput.nBitmaps;
}

void LbmExecStreamTestBase::produceEntry	(	LbmEntry &	lbmEntry,
		TupleAccessor &	bitmapTupleAccessor,
		PBuffer	pBuf,
		uint &	bufSize,
		uint &	nBitmaps,
		bool	includeKeys
	)			[protected, inherited]

Definition at line 196 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::bitmapTupleAccessor, LbmExecStreamTestBase::bitmapTupleData, TupleAccessor::getCurrentByteCount(), LbmExecStreamTestBase::keyBitmapTupleAccessor, LbmExecStreamTestBase::keyBitmapTupleData, TupleAccessor::marshal(), and LbmEntry::produceEntryTuple().

{
    TupleData bitmapTuple = lbmEntry.produceEntryTuple();
    if (includeKeys) {
        int nKeys = keyBitmapTupleData.size() - bitmapTuple.size();
        assert(nKeys > 0);
        for (uint i = 0; i < bitmapTupleData.size(); i++) {
            keyBitmapTupleData[nKeys + i] = bitmapTuple[i];
        }
        keyBitmapTupleAccessor.marshal(keyBitmapTupleData, pBuf + bufSize);
        bufSize += keyBitmapTupleAccessor.getCurrentByteCount();
    } else {
        bitmapTupleAccessor.marshal(bitmapTuple, pBuf + bufSize);
        bufSize += bitmapTupleAccessor.getCurrentByteCount();
    }
    ++nBitmaps;
}

void LbmExecStreamTestBase::initValuesExecStream	(	uint	idx,
		ValuesExecStreamParams &	valuesParams,
		ExecStreamEmbryo &	valuesStreamEmbryo,
		BitmapInput &	bmInput
	)			[protected, inherited]

Definition at line 106 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::bitmapTupleDesc, BitmapInput::bufArray, ValuesExecStreamParams::bufSize, BitmapInput::currBufSize, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), SingleOutputExecStreamParams::outputTupleDesc, and ValuesExecStreamParams::pTupleBuffer.

Referenced by LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmUnionExecStreamTest::testUnion().

{
    valuesParams.outputTupleDesc = bitmapTupleDesc;
    valuesParams.pTupleBuffer = bmInput.bufArray;
    valuesParams.bufSize = bmInput.currBufSize;

    valuesStreamEmbryo.init(new ValuesExecStream(), valuesParams);
    std::ostringstream oss;
    oss << "InputValuesExecStream" << "#" << idx;
    valuesStreamEmbryo.getStream()->setName(oss.str());
}

void LbmExecStreamTestBase::initSorterExecStream	(	ExternalSortExecStreamParams &	params,
		ExecStreamEmbryo &	embryo,
		TupleDescriptor const &	outputDesc,
		uint	nKeys = 1
	)			[protected, inherited]

Definition at line 120 of file LbmExecStreamTestBase.cpp.

References ExternalSortExecStreamParams::distinctness, DUP_ALLOW, ExternalSortExecStreamParams::earlyClose, ExternalSortExecStreamParams::estimatedNumRows, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), ExternalSortExecStreamParams::keyProj, MAXU, ExternalSortExecStream::newExternalSortExecStream(), CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, ExternalSortExecStreamParams::pTempSegment, and ExternalSortExecStreamParams::storeFinalRun.

Referenced by LbmSortedAggExecStreamTest::testSortedAgg(), and LbmUnionExecStreamTest::testUnion().

{
    params.outputTupleDesc = outputDesc;
    params.distinctness = DUP_ALLOW;
    params.pTempSegment = pRandomSegment;
    params.pCacheAccessor = pCache;
    params.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache, 10);
    params.keyProj.clear();
    for (uint i = 0; i < nKeys; i++) {
        params.keyProj.push_back(i);
    }
    params.storeFinalRun = false;
    params.estimatedNumRows = MAXU;
    params.earlyClose = false;

    embryo.init(ExternalSortExecStream::newExternalSortExecStream(), params);
    embryo.getStream()->setName("SorterExecStream");
}

void LbmExecStreamTestBase::initNormalizerExecStream	(	LbmNormalizerExecStreamParams &	params,
		ExecStreamEmbryo &	embryo,
		uint	nKeys
	)			[protected, inherited]

Definition at line 144 of file LbmExecStreamTestBase.cpp.

References ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), LbmExecStreamTestBase::keyBitmapTupleDesc, LbmNormalizerExecStreamParams::keyProj, and TupleDescriptor::projectFrom().

Referenced by LbmNormalizerExecStreamTest::testNormalizer(), and LbmMinusExecStreamTest::testRestartingMinus().

{
    TupleProjection keyProj;
    for (int i = 0; i < nKeys; i++) {
        keyProj.push_back(i);
    }
    params.keyProj = keyProj;

    TupleDescriptor keyDesc;
    keyDesc.projectFrom(keyBitmapTupleDesc, keyProj);
    params.outputTupleDesc = keyDesc;

    embryo.init(new LbmNormalizerExecStream(), params);
    embryo.getStream()->setName("Normalizer");
}

uint LbmExecStreamTestBase::resultBitmapSize	(	uint	start,
		uint	end
	)			[inline, protected, inherited]

Calculates size of result bitmap.

Parameters:

	start	start of result range, inclusive
	end	end of result range, exclusive

Definition at line 339 of file LbmExecStreamTestBase.h.

Referenced by LbmMinusExecStreamTest::test2Inputs(), LbmIntersectExecStreamTest::test2Inputs(), LbmMinusExecStreamTest::test3Inputs(), LbmIntersectExecStreamTest::test3Inputs(), LbmMinusExecStreamTest::testAnchorLarger1(), LbmMinusExecStreamTest::testAnchorLarger2(), LbmMinusExecStreamTest::testChildrenLarger(), LbmIntersectExecStreamTest::testGaps(), LbmIntersectExecStreamTest::testLargeInputs(), LbmMinusExecStreamTest::testLargeOutput(), LbmIntersectExecStreamTest::testLargeOutput(), LbmIntersectExecStreamTest::testSingleBitmaps(), LbmUnionExecStreamTest::testUnion(), and LbmIntersectExecStreamTest::testZeros().

    {
        return resultBitmapSize(end - start);
    }

uint LbmExecStreamTestBase::resultBitmapSize

(

uint

nRids

)

[inline, protected, inherited]

Definition at line 344 of file LbmExecStreamTestBase.h.

    {
        // the result bitmap should be large enough for all rids in range,
        // nRids/8, plus extra space that allows the segment builder some
        // breathing room to operate
        uint extraSpace = 16;
        return (nRids / 8) + extraSpace;
    }

void LbmExecStreamTestBase::initKeyBitmap	(	uint	nRows,
		std::vector< int > const &	repeatSeqValues
	)			[protected, inherited]

Initialize bitmaps with keys.

Definition at line 216 of file LbmExecStreamTestBase.cpp.

References LbmExecStreamTestBase::attrDesc_int64, LbmExecStreamTestBase::bitmapTupleDesc, TupleData::compute(), TupleAccessor::compute(), FixedBuffer, LbmExecStreamTestBase::generateBitmaps(), TupleAccessor::getMaxByteCount(), LbmExecStreamTestBase::getTupleInterval(), LbmExecStreamTestBase::keyBitmapBuf, LbmExecStreamTestBase::keyBitmapBufSize, LbmExecStreamTestBase::keyBitmapTupleAccessor, LbmExecStreamTestBase::keyBitmapTupleData, and LbmExecStreamTestBase::keyBitmapTupleDesc.

Referenced by LbmNormalizerExecStreamTest::testNormalizer(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmSortedAggExecStreamTest::testSortedAgg().

{
    // find the interval for which the entire tuple's sequence repeats
    uint skipRows = getTupleInterval(repeatSeqValues);

    // generate a key bitmap for each distinct input value...
    // configure descriptor
    uint nInputKeys = repeatSeqValues.size();
    keyBitmapTupleDesc.clear();
    for (uint i = 0; i < nInputKeys; i++) {
        keyBitmapTupleDesc.push_back(attrDesc_int64);
    }
    for (uint i = 0; i < bitmapTupleDesc.size(); i++) {
        keyBitmapTupleDesc.push_back(bitmapTupleDesc[i]);
    }

    // configure accessor and key data (bitmap data handled elsewhere)
    keyBitmapTupleAccessor.compute(keyBitmapTupleDesc);
    keyBitmapTupleData.compute(keyBitmapTupleDesc);
    boost::scoped_array<uint64_t> vals(new uint64_t[nInputKeys]);
    for (uint i = 0; i < nInputKeys; i++) {
        keyBitmapTupleData[i].pData = (PConstBuffer) &vals[i];
    }

    uint fullBufSize = nRows * keyBitmapTupleAccessor.getMaxByteCount();
    keyBitmapBuf.reset(new FixedBuffer[fullBufSize]);
    PBuffer pBuf = keyBitmapBuf.get();
    keyBitmapBufSize = 0;
    uint nBitmaps = 0;
    for (uint i = 0; i < skipRows; i++) {
        // generate input keys
        for (uint j = 0; j < nInputKeys; j++) {
            vals[j] = i % repeatSeqValues[j];
        }
        generateBitmaps(
            nRows, i, skipRows, pBuf, keyBitmapBufSize,
            fullBufSize, nBitmaps, true);
    }
}

uint LbmExecStreamTestBase::getTupleInterval	(	std::vector< int > const &	repeatSeqValues,
		uint	nKeys = 0
	)			[static, inherited]

Find the interval for which an entire tuple's sequence repeats.

Definition at line 261 of file LbmExecStreamTestBase.cpp.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), NormalizerExecStreamGenerator::NormalizerExecStreamGenerator(), RestartingMinusExecStreamGenerator::RestartingMinusExecStreamGenerator(), SortedAggExecStreamGenerator::SortedAggExecStreamGenerator(), and LbmSortedAggExecStreamTest::testSortedAgg().

{
    if (nKeys == 0) {
        nKeys = repeatSeqValues.size();
    }
    uint interval = 1;
    for (uint i = 0; i < nKeys; i++) {
        interval *= repeatSeqValues[i];
    }
    return interval;
}

SharedExecStream ExecStreamUnitTestBase::prepareSourceGraph

(

ExecStreamEmbryo &

sourceStreamEmbryo

)

[protected, inherited]

Defines and prepares a graph consisting of one source stream.

Parameters:

sourceStreamEmbryo

embryonic source stream which produces tuples

Returns:

output buffer stream

Definition at line 41 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareTransformGraph().

Referenced by FlatFileExecStreamTest::testStream().

{
    std::vector<ExecStreamEmbryo> transforms;
    return prepareTransformGraph(sourceStreamEmbryo, transforms);
}

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of one source stream and one transform stream.

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transformStreamEmbryo	embryonic transform stream which processes tuples produced by sourceStreamEmbryo

Returns:

output buffer stream

Definition at line 48 of file ExecStreamUnitTestBase.cpp.

Referenced by LcsClusterReplaceExecStreamTest::loadCluster(), LcsRowScanExecStreamTest::loadOneCluster(), ExecStreamUnitTestBase::prepareSourceGraph(), LcsClusterReplaceExecStreamTest::replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectInts(), CollectExecStreamTestSuite::testCollectUncollect(), CalcExecStreamTestSuite::testConstant(), ExecStreamTestSuite::testCopyExecStream(), ExecStreamTestSuite::testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamTestSuite::testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), ExternalSortExecStreamTest::testImpl(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmNormalizerExecStreamTest::testNormalizer(), ExecStreamTestSuite::testReshapeExecStream(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), testScanIdx(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), ExecStreamTestSuite::testScratchBufferExecStream(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), ExecStreamTestSuite::testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), LbmUnionExecStreamTest::testUnion(), and LcsClusterReplaceExecStreamTest::verifyCluster().

{
    std::vector<ExecStreamEmbryo> transforms;
    transforms.push_back(transformStreamEmbryo);
    return prepareTransformGraph(sourceStreamEmbryo, transforms);
}

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	transforms
	)			[protected, inherited]

Defines and prepares a graph consisting of one source stream and one or multiple transform streams.

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transforms	embryonic transform streams which process tuples produced by sourceStreamEmbryo or a child stream

Returns:

output buffer stream

Definition at line 57 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryo);
    std::vector<ExecStreamEmbryo>::iterator it;

    // save all transforms
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }

    // connect streams in a cascade
    ExecStreamEmbryo& previousStream = sourceStreamEmbryo;
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->addDataflow(
            previousStream.getStream()->getName(),
            (*it).getStream()->getName());
        previousStream = *it;
    }

    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            previousStream.getStream()->getName(),
            0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");
    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of two source streams and one confluence stream.

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:

output buffer stream

Definition at line 89 of file ExecStreamUnitTestBase.cpp.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamTestSuite::testCartesianJoinExecStream(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LcsRowScanExecStreamTest::testFilterCols(), ExecStreamGovernorTest::testGovernor(), LhxJoinExecStreamTest::testImpl(), LbmIntersectExecStreamTest::testIntersect(), ExecStreamTestSuite::testMergeExecStream(), LbmMinusExecStreamTest::testMinus(), and ExecStreamTestSuite::testNestedLoopJoinExecStream().

{
    std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
    sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
    sourceStreamEmbryos.push_back(sourceStreamEmbryo2);
    return prepareConfluenceGraph(sourceStreamEmbryos, confluenceStreamEmbryo);
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< ExecStreamEmbryo > &	sourceStreamEmbryos,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of a list of source streams and one confluence stream.

Parameters:

	sourceStreamEmbryos	list of embryonic source streams that produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:

output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

{
    std::vector<std::vector<ExecStreamEmbryo> > sourceStreamEmbryosList;
    std::vector<ExecStreamEmbryo>::iterator it;
    std::vector<ExecStreamEmbryo> sourceStreamList;
    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        it++)
    {
        sourceStreamList.clear();
        sourceStreamList.push_back(*it);
        sourceStreamEmbryosList.push_back(sourceStreamList);
    }

    return
        prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo);
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< std::vector< ExecStreamEmbryo > > &	sourceStreamEmbryosList,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of one or more source streams and one confluence stream.

Each source stream can be a list of streams.

Parameters:

	sourceStreamEmbryosList	list of embryonic source streams which produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the source streams

Returns:

output buffer stream

Definition at line 174 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);

    for (int i = 0; i < sourceStreamEmbryosList.size(); i++) {
        for (int j = 0; j < sourceStreamEmbryosList[i].size(); j++) {
            pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryosList[i][j]);
        }

        // connect streams in each sourceStreamEmbryos list in a cascade
        for (int j = 1; j < sourceStreamEmbryosList[i].size(); j++) {
            pGraphEmbryo->addDataflow(
                sourceStreamEmbryosList[i][j - 1].getStream()->getName(),
                sourceStreamEmbryosList[i][j].getStream()->getName());
        }
        pGraphEmbryo->addDataflow(
            sourceStreamEmbryosList[i].back().getStream()->getName(),
            confluenceStreamEmbryo.getStream()->getName());
    }

    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            confluenceStreamEmbryo.getStream()->getName(), 0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(
        pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");

    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos
	transformStreamEmbryo	embryonic transform streams which process tuples produced by a child stream

Returns:

output buffer stream

Definition at line 100 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by LhxJoinExecStreamTest::testImpl(), and LbmMinusExecStreamTest::testRestartingMinus().

{
    std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
    sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
    sourceStreamEmbryos.push_back(sourceStreamEmbryo2);

    std::vector<ExecStreamEmbryo>::iterator it;

    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        ++it)
    {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }
    pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);

    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        ++it)
    {
        pGraphEmbryo->addDataflow(
            (*it).getStream()->getName(),
            confluenceStreamEmbryo.getStream()->getName());
    }

    std::vector<ExecStreamEmbryo> transforms;
    transforms.push_back(transformStreamEmbryo);
    ExecStreamEmbryo& previousStream = confluenceStreamEmbryo;

    // save all transforms
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }

    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->addDataflow(
            previousStream.getStream()->getName(),
            (*it).getStream()->getName());
        previousStream = *it;
    }


    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            previousStream.getStream()->getName(),
            0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");
    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	interStreamEmbryos,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = true,
		bool	saveSrc = true
	)			[protected, inherited]

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryos	embryonic intermediate streams which transform tuples; each stream consists of a single embryo
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

Returns:

output buffer stream or null stream if createSink is false

Definition at line 208 of file ExecStreamUnitTestBase.cpp.

Referenced by LcsMultiClusterAppendTest::loadClusters(), loadTableAndIndex(), LbmLoadBitmapTest::testLoad(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), and ExecStreamTestSuite::testSplitterPlusBarrier().

{
    std::vector<std::vector<ExecStreamEmbryo> > listOfList;

    // Convert interStreamEmbryos to a vector of vectors.  E.g., if
    // interStreamEmbryos contains (1, 2, 3), it will get converted to:
    // ((1)) ((2)) ((3))
    for (uint i = 0; i < interStreamEmbryos.size(); i++) {
        std::vector<ExecStreamEmbryo> interStreamEmbryoList;

        interStreamEmbryoList.push_back(interStreamEmbryos[i]);
        listOfList.push_back(interStreamEmbryoList);
    }
    return prepareDAG(
        srcStreamEmbryo, splitterStreamEmbryo, listOfList, destStreamEmbryo,
        createSink, saveSrc);
}

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< std::vector< ExecStreamEmbryo > > &	interStreamEmbryosList,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = true,
		bool	saveSrc = true
	)			[protected, inherited]

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryosList	one or more embryonic intermediate streams which transform tuples; each stream can have one more embryos
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

Returns:

output buffer stream or null stream if createSink is false

Definition at line 232 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    if (saveSrc) {
        pGraphEmbryo->saveStreamEmbryo(srcStreamEmbryo);
    }
    pGraphEmbryo->saveStreamEmbryo(splitterStreamEmbryo);

    // save all intermediate stream embryos
    for (int i = 0; i < interStreamEmbryos.size(); i++) {
        for (int j = 0; j < interStreamEmbryos[i].size(); j++) {
            pGraphEmbryo->saveStreamEmbryo(interStreamEmbryos[i][j]);
        }

        // connect streams in each interStreamEmbryos list in a cascade
        for (int j = 1; j < interStreamEmbryos[i].size(); j++) {
            pGraphEmbryo->addDataflow(
                interStreamEmbryos[i][j - 1].getStream()->getName(),
                interStreamEmbryos[i][j].getStream()->getName());
        }
    }

    pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo);

    pGraphEmbryo->addDataflow(
        srcStreamEmbryo.getStream()->getName(),
        splitterStreamEmbryo.getStream()->getName());

    // connect all inter streams to src and dest
    for (int i = 0; i < interStreamEmbryos.size(); i++) {
        pGraphEmbryo->addDataflow(
            splitterStreamEmbryo.getStream()->getName(),
            interStreamEmbryos[i][0].getStream()->getName());
        pGraphEmbryo->addDataflow(
            interStreamEmbryos[i].back().getStream()->getName(),
            destStreamEmbryo.getStream()->getName());
    }

    SharedExecStream pAdaptedStream;

    if (createSink) {
        pAdaptedStream = pGraphEmbryo->addAdapterFor(
            destStreamEmbryo.getStream()->getName(), 0,
            BUFPROV_PRODUCER);
        pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

        pGraphEmbryo->prepareGraph(shared_from_this(), "");
    }

    return pAdaptedStream;
}

void ExecStreamUnitTestBase::verifyOutput	(	ExecStream &	stream,
		uint	nRowsExpected,
		MockProducerExecStreamGenerator &	verifier,
		bool	stopEarly = false
	)			[protected, inherited]

Executes the prepared stream graph and verifies that its output matches that produced by a value generator.

Parameters:

	stream	output stream from which to read
	nRowsExpected	number of rows expected
	verifier	generator for expected values
	stopEarly	if true, stop once nRowsExpected have been fetched, even if more rows are available; this can be used for simulating the cleanup effect of an error in the middle of execution

Definition at line 325 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, MockProducerExecStreamGenerator::generateValue(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, and ExecStreamTestBase::pScheduler.

Referenced by LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), loadTableAndIndex(), LcsClusterReplaceExecStreamTest::replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectUncollect(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), ExecStreamTestSuite::testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), LcsRowScanExecStreamTest::testFilterCols(), ExecStreamTestSuite::testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testNestedLoopJoinExecStream(), LbmNormalizerExecStreamTest::testNormalizer(), ExecStreamTestSuite::testReshapeExecStream(), LbmMinusExecStreamTest::testRestartingMinus(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), ExecStreamTestSuite::testScratchBufferExecStream(), ExecStreamTestSuite::testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), ExecStreamTestSuite::testSplitterPlusBarrier(), ExecStreamTestSuite::testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), and LcsClusterReplaceExecStreamTest::verifyCluster().

{
    // TODO:  assertions about output tuple

    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
        const uint nCol =
            bufAccessor.getConsumptionTupleAccessor().size();
        BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
        BOOST_REQUIRE(nCol >= 1);
        TupleData inputTuple;
        inputTuple.compute(bufAccessor.getTupleDesc());
        for (;;) {
            if (!bufAccessor.demandData()) {
                break;
            }
            BOOST_REQUIRE(nRows < nRowsExpected);
            bufAccessor.unmarshalTuple(inputTuple);
            for (int col = 0; col < nCol; ++col) {
                int64_t actualValue =
                    *reinterpret_cast<int64_t const *>(inputTuple[col].pData);
                int64_t expectedValue = generator.generateValue(nRows, col);
                if (actualValue != expectedValue) {
                    std::cout << "(Row, Col) = (" << nRows << ", " << col <<")"
                              << std::endl;
                    BOOST_CHECK_EQUAL(expectedValue,actualValue);
                    return;
                }
            }
            bufAccessor.consumeTuple();
            ++nRows;
            if (stopEarly && nRows == nRowsExpected) {
                return;
            }
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected,nRows);
}

void ExecStreamUnitTestBase::verifyConstantOutput	(	ExecStream &	stream,
		const TupleData &	expectedTuple,
		uint	nRowsExpected
	)			[protected, inherited]

Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.

Parameters:

	stream	output stream from which to read
	expectedTuple
	nRowsExpected

Definition at line 377 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, TuplePrinter::print(), and ExecStreamTestBase::pScheduler.

Referenced by ExecStreamTestSuite::testCartesianJoinExecStream(), CollectExecStreamTestSuite::testCollectInts(), CalcExecStreamTestSuite::testConstant(), ExecStreamTestSuite::testCopyExecStream(), ExecStreamGovernorTest::testGovernor(), ExecStreamTestSuite::testMergeExecStream(), ExecStreamTestSuite::testSegBufferExecStream(), and ExecStreamTestSuite::testSegBufferReaderWriterExecStream().

{
    // TODO:  assertions about output tuple

    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());

        if (!bufAccessor.demandData()) {
            break;
        }
        BOOST_REQUIRE(nRows < nRowsExpected);

        TupleData actualTuple;
        actualTuple.compute(bufAccessor.getTupleDesc());
        bufAccessor.unmarshalTuple(actualTuple);

        int c = bufAccessor.getTupleDesc().compareTuples(
                               expectedTuple, actualTuple);
        bufAccessor.consumeTuple();
        ++nRows;
        if (c) {
#if 1
            TupleDescriptor statusDesc = bufAccessor.getTupleDesc();
            TuplePrinter tuplePrinter;
            tuplePrinter.print(std::cout, statusDesc, actualTuple);
            tuplePrinter.print(std::cout, statusDesc, expectedTuple);
            std::cout << std::endl;
#endif
            BOOST_CHECK_EQUAL(0,c);
            break;
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected, nRows);
}

void ExecStreamUnitTestBase::verifyBufferedOutput	(	ExecStream &	stream,
		TupleDescriptor	outputTupleDesc,
		uint	nRowsExpected,
		PBuffer	expectedBuffer
	)			[protected, inherited]

Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.

Parameters:

	stream	output stream from which to read
	outputTupleDesc	descriptor of expected output tuple
	nRowsExpected	number of rows expected
	expectedBuffer	buffer containing expected tuples

Definition at line 424 of file ExecStreamUnitTestBase.cpp.

References TupleDescriptor::compareTuples(), TupleData::compute(), TupleAccessor::compute(), EXECBUF_EOS, TupleAccessor::getCurrentByteCount(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, TupleAccessor::setCurrentTupleBuf(), and TupleAccessor::unmarshal().

Referenced by LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), testScanIdx(), and LbmUnionExecStreamTest::testUnion().

{
    // TODO:  assertions about output tuple

    TupleAccessor expectedOutputAccessor;
    expectedOutputAccessor.compute(outputTupleDesc);
    TupleData expectedTuple(outputTupleDesc);
    uint bufOffset = 0;
    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.getTupleDesc() == outputTupleDesc);
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
        const uint nCol =
            bufAccessor.getConsumptionTupleAccessor().size();
        BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
        BOOST_REQUIRE(nCol >= 1);
        TupleData inputTuple;
        inputTuple.compute(bufAccessor.getTupleDesc());
        for (;;) {
            if (!bufAccessor.demandData()) {
                break;
            }
            BOOST_REQUIRE(nRows < nRowsExpected);
            bufAccessor.unmarshalTuple(inputTuple);
            expectedOutputAccessor.setCurrentTupleBuf(
                expectedBuffer + bufOffset);
            expectedOutputAccessor.unmarshal(expectedTuple);
            int c = outputTupleDesc.compareTuples(inputTuple, expectedTuple);
            if (c) {
                std::cout << "(Row) = (" << nRows << ")"
                    << " -- Tuples don't match"<< std::endl;
                BOOST_CHECK_EQUAL(0,c);
                return;
            }
            bufAccessor.consumeTuple();
            bufOffset += expectedOutputAccessor.getCurrentByteCount();
            ++nRows;
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected,nRows);
}

void ExecStreamUnitTestBase::resetExecStreamTest

(

)

[protected, inherited]

Reset stream graph so multiple iterations of a method can be called within a single testcase.

Definition at line 305 of file ExecStreamUnitTestBase.cpp.

References ExecStreamTestBase::newScheduler(), ExecStreamTestBase::newStreamGraph(), ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::pGraphEmbryo, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, and ExecStreamUnitTestBase::tearDownExecStreamTest().

Referenced by LcsRowScanExecStreamTest::loadClusters(), LbmLoadBitmapTest::testAppend(), LcsRowScanExecStreamTest::testBernoulliSampling(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LcsRowScanExecStreamTest::testCompressedFiltering(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), LcsMultiClusterAppendTest::testLoad(), LcsClusterAppendExecStreamTest::testMultiColConstNewRoot(), LcsClusterAppendExecStreamTest::testMultiColConstOldRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testMultiColStairNewRoot(), LcsClusterAppendExecStreamTest::testMultiColStairOldRoot(), testMultipleRanges(), ExecStreamGovernorTest::testReturnResources(), testScanIdx(), LcsRowScanExecStreamTest::testScanPastEndOfCluster(), LcsRowScanExecStreamTest::testScans(), LcsClusterAppendExecStreamTest::testSingleColConstNewRoot(), LcsClusterAppendExecStreamTest::testSingleColConstOldRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testSingleColStairNewRoot(), LcsClusterAppendExecStreamTest::testSingleColStairOldRoot(), LbmSplicerExecStreamTest::testSpliceRids(), LbmSplicerExecStreamTest::testSpliceWithKeys(), and LcsRowScanExecStreamTest::testSystemSampling().

{
    if (pScheduler) {
        pScheduler->stop();
    }
    tearDownExecStreamTest();

    pScheduler.reset(newScheduler());
    pGraph = newStreamGraph();
    pGraphEmbryo = newStreamGraphEmbryo(pGraph);
    pGraph->setResourceGovernor(pResourceGovernor);
}

void ExecStreamUnitTestBase::tearDownExecStreamTest

(

)

[protected, virtual, inherited]

ExecStream-specific handler called from testCaseTearDown.

Reimplemented from ExecStreamTestBase.

Definition at line 319 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest().

{
    pGraph.reset();
    pGraphEmbryo.reset();
}

SharedExecStreamGraph ExecStreamTestBase::newStreamGraph

(

)

[protected, virtual, inherited]

Creates a stream graph.

Definition at line 37 of file ExecStreamTestBase.cpp.

References ExecStreamGraph::newExecStreamGraph().

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

{
    SharedExecStreamGraph pGraph = ExecStreamGraph::newExecStreamGraph();
    pGraph->enableDummyTxnId(true);
    return pGraph;
}

SharedExecStreamGraphEmbryo ExecStreamTestBase::newStreamGraphEmbryo

(

SharedExecStreamGraph

)

[protected, virtual, inherited]

Creates an embryo for a stream graph.

Definition at line 45 of file ExecStreamTestBase.cpp.

References CacheTestBase::pCache, ExecStreamTestBase::pScheduler, and SegStorageTestBase::pSegmentFactory.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

{
    return SharedExecStreamGraphEmbryo(
        new ExecStreamGraphEmbryo(
            g, pScheduler, pCache, pSegmentFactory));
}

ExecStreamScheduler * ExecStreamTestBase::newScheduler

(

)

[protected, virtual, inherited]

Creates a scheduler.

Reimplemented in ParallelExecStreamSchedulerTest.

Definition at line 52 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamTestBase::testCaseSetUp().

{
    return new DfsTreeExecStreamScheduler(
        shared_from_this(),
        "DfsTreeExecStreamScheduler");
}

ExecStreamGovernor * ExecStreamTestBase::newResourceGovernor	(	ExecStreamResourceKnobs const &	knobSettings,
		ExecStreamResourceQuantity const &	resourcesAvailable
	)			[protected, virtual, inherited]

Creates the resource governor.

Definition at line 59 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

{
    return new SimpleExecStreamGovernor(
        knobSettings, resourcesAvailable, shared_from_this(),
        "SimpleExecStreamGovernor");
}

void SegStorageTestBase::openStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SegmentTestBase.

Definition at line 31 of file SegStorageTestBase.cpp.

References SegStorageTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

Referenced by SegStorageTestBase::openRandomSegment(), SegmentTestBase::openStorage(), LhxHashTableTest::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LbmEntryTest::testCaseSetUp(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), LogicalTxnTest::testTxn(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

{
    CacheTestBase::openStorage(openMode);
    openSegmentStorage(openMode);
}

void SegStorageTestBase::openSegmentStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented in LinearViewSegmentTest, SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 37 of file SegStorageTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, SegStorageTestBase::createLinearDeviceSegment(), CacheTestBase::dataDeviceId, SegStorageTestBase::pLinearSegment, and CacheTestBase::pRandomAccessDevice.

Referenced by VersionedSegmentTest::openSegmentStorage(), and SegStorageTestBase::openStorage().

{
    pLinearSegment = createLinearDeviceSegment(
        dataDeviceId,
        openMode.create ? 0
        : pRandomAccessDevice->getSizeInBytes() / cbPageFull);
}

void SegStorageTestBase::openRandomSegment

(

)

[virtual, inherited]

Reimplemented in LcsClusterReplaceExecStreamTest.

Definition at line 45 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeStorage(), DeviceMode::load, SegStorageTestBase::openStorage(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, and SegStorageTestBase::pSegmentFactory.

Referenced by RandomAllocationSegmentTest::testAllocateAndDeallocate(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), and BTreeReadersTest::testCaseSetUp().

{
    // reopen will interpret pages as already allocated, which
    // is what RandomAllocationSegment expects
    closeStorage();
    openStorage(DeviceMode::load);
    pRandomSegment = pSegmentFactory->newRandomAllocationSegment(
        pLinearSegment, true);
    pLinearSegment.reset();
}

SharedSegment SegStorageTestBase::createLinearDeviceSegment	(	DeviceId	deviceId,
		uint	nPages
	)			[inherited]

Definition at line 56 of file SegStorageTestBase.cpp.

References LinearDeviceSegmentParams::firstBlockId, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesMin, CacheTestBase::pCache, SegStorageTestBase::pSegmentFactory, CompoundId::setBlockNum(), and CompoundId::setDeviceId().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), and LinearViewSegmentTest::openSegmentStorage().

{
    BlockId blockId(0);
    CompoundId::setDeviceId(blockId,deviceId);
    CompoundId::setBlockNum(blockId,0);
    LinearDeviceSegmentParams deviceParams;
    deviceParams.firstBlockId = blockId;
    deviceParams.nPagesMin = nPages;
    deviceParams.nPagesAllocated = nPages;
    return pSegmentFactory->newLinearDeviceSegment(
        pCache,deviceParams);
}

void SegStorageTestBase::closeLinearSegment

(

)

[inherited]

Definition at line 70 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pLinearSegment.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeStorage(), and SnapshotSegmentTest::testUncommittedReads().

{
    if (pLinearSegment) {
        assert(pLinearSegment.unique());
        pLinearSegment.reset();
    }
}

void SegStorageTestBase::closeRandomSegment

(

)

[inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

Referenced by VersionedSegmentTest::closeStorage(), and SegStorageTestBase::closeStorage().

{
    if (pRandomSegment) {
        assert(pRandomSegment.unique());
        pRandomSegment.reset();
    }
}

void SegStorageTestBase::closeVersionedRandomSegment

(

)

[inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage(), and SegStorageTestBase::closeStorage().

{
    if (pVersionedRandomSegment) {
        assert(pVersionedRandomSegment.unique());
        pVersionedRandomSegment.reset();
    }
}

void SegStorageTestBase::closeSnapshotRandomSegment

(

)

[inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

{
    if (pSnapshotRandomSegment) {
        assert(pSnapshotRandomSegment.unique());
        pSnapshotRandomSegment.reset();
    }
}

void SegStorageTestBase::closeStorage

(

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeRandomSegment(), CacheTestBase::closeStorage(), and SegStorageTestBase::closeVersionedRandomSegment().

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::openRandomSegment(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), SegmentTestBase::testSingleThread(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

{
    closeLinearSegment();
    closeRandomSegment();
    closeVersionedRandomSegment();
    // TODO:  assert pSegmentFactory.unique(), but not here
    CacheTestBase::closeStorage();
}

Cache & CacheTestBase::getCache

(

)

[inherited]

Definition at line 42 of file CacheTestBase.cpp.

References CacheTestBase::pCache.

Referenced by CacheTest::lockPage(), CacheTest::prefetchBatch(), SegmentTestBase::prefetchPage(), CacheTest::prefetchPage(), PagingTestBase::testCacheResize(), PagingTestBase::testCheckpoint(), PagingTestBase::testOp(), PagingTestBase::testScratch(), SegmentTestBase::unlockPage(), and CacheTest::unlockPage().

{
    return *pCache;
}

SharedCache CacheTestBase::newCache

(

)

[virtual, inherited]

Definition at line 66 of file CacheTestBase.cpp.

References CacheTestBase::cacheParams, Cache::newCache(), CacheTestBase::victimLRU, CacheTestBase::victimPolicy, CacheTestBase::victimRandom, and CacheTestBase::victimTwoQ.

Referenced by CacheTestBase::openStorage().

{
    switch (victimPolicy) {
    case victimRandom:
        return SharedCache(
            new RandomCache(cacheParams),
            ClosableObjectDestructor());
    case victimLRU:
        return SharedCache(
            new LRUCache(cacheParams),
            ClosableObjectDestructor());
    case victimTwoQ:
        return Cache::newCache(cacheParams);
    default:
        permAssert(false);
    }
}

SharedRandomAccessDevice CacheTestBase::openDevice	(	std::string	devName,
		DeviceMode	openMode,
		uint	nDevicePages,
		DeviceId	deviceId
	)			[inherited]

Definition at line 84 of file CacheTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, CacheTestBase::pCache, and FileSystem::remove().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

{
    if (openMode.create) {
        FileSystem::remove(devName.c_str());
    }
    SharedRandomAccessDevice pDevice(
        new RandomAccessFileDevice(devName,openMode));
    if (openMode.create) {
        pDevice->setSizeInBytes(nDevicePages*cbPageFull);
    }
    pCache->registerDevice(deviceId,pDevice);
    return pDevice;
}

void CacheTestBase::closeDevice	(	DeviceId	deviceId,
		SharedRandomAccessDevice &	pDevice
	)			[inherited]

Definition at line 130 of file CacheTestBase.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, and CacheTestBase::pCache.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), and CacheTestBase::closeStorage().

{
    if (!pDevice) {
        return;
    }
    DeviceIdPagePredicate pagePredicate(deviceId);
    pCache->checkpointPages(pagePredicate,CHECKPOINT_FLUSH_AND_UNMAP);
    pCache->unregisterDevice(deviceId);
    assert(pDevice.unique());
    pDevice.reset();
}

void TestBase::snooze

(

uint

nSeconds

)

[protected, inherited]

Definition at line 263 of file TestBase.cpp.

Referenced by DatabaseTest::executeForceTxn(), ThreadedTestBase::runThreadedTestCase(), PagingTestBase::testCacheResize(), BTreeTxnTest::testCheckpoint(), PagingTestBase::testCheckpointGuarded(), PagingTestBase::testPrefetch(), and PagingTestBase::testPrefetchBatch().

{
#ifdef __MSVC__
    ::_sleep(nSeconds*1000);
#else
    ::sleep(nSeconds);
#endif
}

void TestBase::readParams	(	int	argc,
		char **	argv
	)			[static, inherited]

Parses the command line.

format: [-v] [-t TEST | -all] {param=val}* [CONFIGFILE | -] Normally, the test program runs the default test cases. With the option "-all", runs the extra test cases as well. With the option "-t TEST", runs only the single test case named TEST. CONFIGFILE is read to load configuration parameters. Configuration parameters can also be set ad hoc, from the command line, as pairs name=val. These take precedence.

Definition at line 108 of file TestBase.cpp.

References TestBase::configMap, ConfigMap::dumpParams(), ConfigMap::isParamSet(), ConfigMap::mergeFrom(), TestBase::paramDictionaryFileName, ConfigMap::readParams(), TestBase::runAll, TestBase::runSingle, ConfigMap::setStringParam(), and verbose.

{
    bool verbose = false;
    ConfigMap adhocMap;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (argv[i][0] == '-') {
            if (arg == "-v") {
                verbose = true;
            } else if (arg == "-") {
                configMap.readParams(std::cin);
            } else if (arg == "-all") {
                runAll = true;
            } else if (arg == "-t") {   // -t TEST
                permAssert(i + 1 < argc);
                runSingle = argv[++i];
            } else if (arg[1] == 't') { // allow -tTEST
                runSingle = arg.substr(2);
            }
        } else {
            int i = arg.find("=");
            if ((0 < i) && (i < arg.size())) {
                // an ad hoc parameter
                std::string key = arg.substr(0,i);
                std::string val = arg.substr(i + 1);
                adhocMap.setStringParam(key,val);
            } else {
                // a config file name
                std::ifstream configFile(arg.c_str());
                assert(configFile.good());
                configMap.readParams(configFile);
            }
        }
    }
    configMap.mergeFrom(adhocMap);

    // set a default dictionary file location for use by tests that need a
    // small non-random sorted data set
    if (!configMap.isParamSet(paramDictionaryFileName)) {
        std::string dictFileName = "dictWords";
        configMap.setStringParam(paramDictionaryFileName,dictFileName);
    }

    if (verbose) {
        configMap.dumpParams(std::cout);
    }
}

TestSuite * TestBase::releaseTestSuite

(

)

[inherited]

Definition at line 157 of file TestBase.cpp.

References TestBase::TestCaseGroup::addAllToTestSuite(), TestBase::defaultTests, TestBase::extraTests, TestBase::TestCaseGroup::findTest(), TestBase::pTestObj, TestBase::pTestSuite, TestBase::runAll, TestBase::runSingle, and TestBase::testName.

{
    assert(pTestObj);
    assert(pTestObj.use_count() > 1);

    // release self-reference now that all test cases have been registered
    pTestObj.reset();

    TestSuite* pTestSuite = BOOST_TEST_SUITE(testName.c_str());

    if (runSingle.size()) {
        test_unit *p =  defaultTests.findTest(runSingle);
        if (!p) {
            p = extraTests.findTest(runSingle);
        }
        if (!p) {
            std::cerr << "test " << runSingle << " not found\n";
            exit(2);
        }
        pTestSuite->add(p);
    } else {
        defaultTests.addAllToTestSuite(pTestSuite);
        if (runAll) {
            extraTests.addAllToTestSuite(pTestSuite);
        }
    }
    return pTestSuite;
}

void TestBase::beforeTestCase

(

std::string

testCaseName

)

[inherited]

Definition at line 214 of file TestBase.cpp.

References TestBase::configMap, TraceSource::initTraceSource(), AutoBacktrace::install(), TestBase::notifyTrace(), AutoBacktrace::setOutputStream(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

{
    notifyTrace(testName,TRACE_INFO,"ENTER:  " + testCaseName);

    // Install the AutoBacktrace signal handler now, after
    // boost::execution_monitor::catch_signals() has installed its own, so that
    // on SIGABRT AutoBacktrace goes first, prints the backtrace, then chains
    // to boost, which handles the error.
    AutoBacktrace::setOutputStream();
    AutoBacktrace::setTraceTarget(shared_from_this());
    AutoBacktrace::install();
    configMap.initTraceSource(shared_from_this(), "testConfig");
}

void TestBase::afterTestCase

(

std::string

testCaseName

)

[inherited]

Definition at line 228 of file TestBase.cpp.

References TestBase::configMap, TraceSource::disableTracing(), TestBase::notifyTrace(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

{
    AutoBacktrace::setTraceTarget();
    configMap.disableTracing();
    notifyTrace(testName,TRACE_INFO,"LEAVE:  " + testCaseName);
}

void TestBase::notifyTrace	(	std::string	source,
		TraceLevel	level,
		std::string	message
	)			[virtual, inherited]

Receives notification when a trace event occurs.

Parameters:

	source	the facility from which the message originated
	level	the trace event severity level
	message	the text of the message

Implements TraceTarget.

Definition at line 243 of file TestBase.cpp.

References TestBase::traceFile, TestBase::traceMutex, TestBase::traceStdout, and TestBase::traceStream.

Referenced by TestBase::afterTestCase(), and TestBase::beforeTestCase().

{
    if (traceFile || traceStdout) {
        StrictMutexGuard traceMutexGuard(traceMutex);
        if (traceFile) {
            traceStream << "[" << source << "] " << message << std::endl;
            traceStream.flush();
        }
        if (traceStdout) {
            std::cout << "[" << source << "] " << message << std::endl;
            std::cout.flush();
        }
    }
}

TraceLevel TestBase::getSourceTraceLevel

(

std::string

source

)

[virtual, inherited]

Gets the level at which a particular source should be traced.

Parameters:

source

name of source to be traced

Returns:

minimum severity level which should be traced

Implements TraceTarget.

Definition at line 258 of file TestBase.cpp.

References TestBase::traceLevel.

Referenced by LbmExecStreamTestBase::generateBitmaps().

{
    return traceLevel;
}

---

Member Data Documentation

TupleAttributeDescriptor LbmSearchTest::attrDesc_char1 [protected]

Definition at line 58 of file LbmSearchTest.cpp.

Referenced by initEqualSearch(), testCaseSetUp(), testMultipleRanges(), and testScanIdx().

TupleAttributeDescriptor LbmSearchTest::attrDesc_nullableInt64 [protected]

Definition at line 59 of file LbmSearchTest.cpp.

Referenced by initEqualSearch(), testCaseSetUp(), testMultipleRanges(), and testScanIdx().

vector<boost::shared_ptr<BTreeDescriptor> > LbmSearchTest::bTreeClusters [protected]

BTrees corresponding to the clusters.

Definition at line 64 of file LbmSearchTest.cpp.

Referenced by initClusterScanDef(), loadTableAndIndex(), and testCaseTearDown().

vector<PageId> LbmSearchTest::savedBTreeClusterRootIds [protected]

Saved root pageids of btrees corresponding to clusters; used to append to existing table and to read from them.

Definition at line 70 of file LbmSearchTest.cpp.

Referenced by loadTableAndIndex(), and testCaseTearDown().

vector<boost::shared_ptr<BTreeDescriptor> > LbmSearchTest::bTreeBitmaps [protected]

BTrees corresponding to the bitmaps.

Definition at line 75 of file LbmSearchTest.cpp.

Referenced by loadTableAndIndex(), testCaseTearDown(), and testScanIdx().

vector<PageId> LbmSearchTest::savedBTreeBitmapRootIds [protected]

Saved root pageids of btrees corresponding to bitmaps; used to append to existing table and to read from them.

Definition at line 81 of file LbmSearchTest.cpp.

Referenced by loadTableAndIndex(), testCaseTearDown(), and testScanIdx().

StandardTypeDescriptorFactory LbmExecStreamTestBase::stdTypeFactory [protected, inherited]

Definition at line 273 of file LbmExecStreamTestBase.h.

Referenced by testCaseSetUp(), and LbmExecStreamTestBase::testCaseSetUp().

TupleAttributeDescriptor LbmExecStreamTestBase::attrDesc_int64 [protected, inherited]

Definition at line 274 of file LbmExecStreamTestBase.h.

Referenced by initBTreeTupleDesc(), LbmExecStreamTestBase::initKeyBitmap(), loadTableAndIndex(), LbmExecStreamTestBase::testCaseSetUp(), testScanIdx(), and LbmSortedAggExecStreamTest::testSortedAgg().

TupleAttributeDescriptor LbmExecStreamTestBase::attrDesc_bitmap [protected, inherited]

Definition at line 275 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::testCaseSetUp().

uint LbmExecStreamTestBase::bitmapColSize [protected, inherited]

Size of bitmap columns.

Definition at line 280 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::generateBitmaps(), and LbmExecStreamTestBase::testCaseSetUp().

TupleDescriptor LbmExecStreamTestBase::bitmapTupleDesc [protected, inherited]

Tuple descriptor, tupledata, and accessor for a bitmap segment: (rid, segment descriptor, bitmap segments).

Definition at line 286 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::generateBitmaps(), initBTreeTupleDesc(), LbmExecStreamTestBase::initKeyBitmap(), LbmExecStreamTestBase::initValuesExecStream(), LbmExecStreamTestBase::testCaseSetUp(), LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), testScanIdx(), LbmReaderTest::testSingleTupleReader(), and LbmUnionExecStreamTest::testUnion().

TupleData LbmExecStreamTestBase::bitmapTupleData [protected, inherited]

Definition at line 287 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::generateBitmaps(), LbmExecStreamTestBase::produceEntry(), LbmExecStreamTestBase::testCaseSetUp(), and LbmReaderTest::testSingleTupleReader().

TupleAccessor LbmExecStreamTestBase::bitmapTupleAccessor [protected, inherited]

Definition at line 288 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::generateBitmaps(), LbmExecStreamTestBase::produceEntry(), LbmExecStreamTestBase::testCaseSetUp(), testScanIdx(), and LbmUnionExecStreamTest::testUnion().

TupleDescriptor LbmExecStreamTestBase::keyBitmapTupleDesc [protected, inherited]

Tuple descriptor, data, and accessor for key-containting bitmaps (keys, srid, segment descriptor, bitmap segments).

Definition at line 294 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), LbmExecStreamTestBase::initNormalizerExecStream(), LbmNormalizerExecStreamTest::testNormalizer(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmSortedAggExecStreamTest::testSortedAgg().

TupleData LbmExecStreamTestBase::keyBitmapTupleData [protected, inherited]

Definition at line 295 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), and LbmExecStreamTestBase::produceEntry().

TupleAccessor LbmExecStreamTestBase::keyBitmapTupleAccessor [protected, inherited]

Definition at line 296 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), and LbmExecStreamTestBase::produceEntry().

boost::shared_array<FixedBuffer> LbmExecStreamTestBase::keyBitmapBuf [protected, inherited]

Definition at line 297 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), LbmNormalizerExecStreamTest::testNormalizer(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmSortedAggExecStreamTest::testSortedAgg().

uint LbmExecStreamTestBase::keyBitmapBufSize [protected, inherited]

Definition at line 298 of file LbmExecStreamTestBase.h.

Referenced by LbmExecStreamTestBase::initKeyBitmap(), LbmNormalizerExecStreamTest::testNormalizer(), LbmMinusExecStreamTest::testRestartingMinus(), and LbmSortedAggExecStreamTest::testSortedAgg().

SharedExecStreamGraph ExecStreamUnitTestBase::pGraph [protected, inherited]

Definition at line 46 of file ExecStreamUnitTestBase.h.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamUnitTestBase::prepareConfluenceTransformGraph(), ExecStreamUnitTestBase::prepareDAG(), ExecStreamUnitTestBase::prepareTransformGraph(), ExecStreamUnitTestBase::resetExecStreamTest(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamUnitTestBase::tearDownExecStreamTest(), ExecStreamTestSuite::testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), ExecStreamTestSuite::testReshapeExecStream(), testScanIdx(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedExecStreamGraphEmbryo ExecStreamUnitTestBase::pGraphEmbryo [protected, inherited]

Definition at line 47 of file ExecStreamUnitTestBase.h.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamUnitTestBase::prepareConfluenceTransformGraph(), ExecStreamUnitTestBase::prepareDAG(), ExecStreamUnitTestBase::prepareTransformGraph(), ExecStreamUnitTestBase::resetExecStreamTest(), ExecStreamUnitTestBase::tearDownExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

const uint ExecStreamTestBase::DefaultCacheReservePercent = 5 [static, protected, inherited]

Definition at line 45 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

const uint ExecStreamTestBase::DefaultConcurrentStatements = 4 [static, protected, inherited]

Definition at line 47 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

SharedExecStreamScheduler ExecStreamTestBase::pScheduler [protected, inherited]

Definition at line 49 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::resetExecStreamTest(), ExecStreamTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedExecStreamGovernor ExecStreamTestBase::pResourceGovernor [protected, inherited]

Definition at line 51 of file ExecStreamTestBase.h.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), ExternalSortExecStreamTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), ExecStreamGovernorTest::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamGovernorTest::testMinGreaterAllocation(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedCacheAccessor ExecStreamTestBase::pCacheAccessor [protected, inherited]

Definition at line 53 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestSuite::testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferExecStream(), and ExecStreamTestSuite::testSegBufferReaderWriterExecStream().

SharedSegmentFactory SegStorageTestBase::pSegmentFactory [protected, inherited]

Definition at line 40 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), loadTableAndIndex(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), BackupRestoreTest::restore(), SegStorageTestBase::SegStorageTestBase(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), LhxHashTableTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), BTreeTest::testScan(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

SharedSegment SegStorageTestBase::pLinearSegment [protected, inherited]

Segment supporting linear page allocation.

Definition at line 45 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeLinearSegment(), LogicalTxnTest::createRecoveryLog(), SegmentTestBase::lockPage(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::prefetchPage(), SnapshotSegmentTestBase::testAllocateAll(), LinearViewSegmentTest::testAllocateAll(), VersionedSegmentTest::testCheckpoint(), SegmentTestBase::testCheckpoint(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), VersionedSegmentTest::testRecovery(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), SegStreamTest::testWriteSeg(), and VersionedSegmentTest::verifyPage().

SharedSegment SegStorageTestBase::pRandomSegment [protected, inherited]

(Optional) segment supporting random page allocation.

Definition at line 50 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeRandomSegment(), SnapshotSegmentTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), LbmSplicerExecStreamTest::initBTreeParam(), initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeTupleDesc(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), loadTableAndIndex(), SegStorageTestBase::openRandomSegment(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LcsRowScanExecStreamTest::testCaseSetUp(), LcsMultiClusterAppendTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testCaseSetUp(), LcsClusterAppendExecStreamTest::testCaseSetUp(), LbmExecStreamTestBase::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), ExecStreamTestSuite::testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), BTreeReadersTest::testReaders(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LhxAggExecStreamTest::testSumImpl(), and LbmUnionExecStreamTest::testUnion().

SharedSegment SegStorageTestBase::pVersionedRandomSegment [protected, inherited]

(Optional) segment supporting versioned random page allocation.

Definition at line 55 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeVersionedRandomSegment(), SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTestBase::openSegmentStorage(), BackupRestoreTest::restore(), LcsClusterReplaceExecStreamTest::testClusterReplace(), SnapshotSegmentTest::testRollback(), and SnapshotSegmentTest::testUncommittedReads().

SharedSegment SegStorageTestBase::pSnapshotRandomSegment [protected, inherited]

(Optional) segment supporting snapshot random page allocation.

Definition at line 60 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeSnapshotRandomSegment(), SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::openSegmentStorage(), LcsClusterReplaceExecStreamTest::testClusterReplace(), and SnapshotSegmentTest::testDeallocateOld().

VictimPolicy CacheTestBase::victimPolicy [protected, inherited]

VictimPolicy to instantiate.

Definition at line 53 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), and CacheTestBase::newCache().

CacheParams CacheTestBase::cacheParams [protected, inherited]

Parameters for cache initialization.

Definition at line 58 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::newCache(), BackupRestoreTest::testBackupCleanup(), BackupRestoreTest::testHeaderBackupRestore(), and SegPageEntryIterTest::testIter().

SharedCache CacheTestBase::pCache [protected, inherited]

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeDevice(), CacheTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), CacheTestBase::getCache(), initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), LcsClusterReplaceExecStreamTest::replaceCluster(), BackupRestoreTest::restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupCleanup(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), BackupRestoreTest::testHeaderBackupRestore(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), CacheTest::testLargeCacheInit(), CacheTest::testLargeCacheRequest(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), SegStreamTest::testMarkReset(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), CacheTest::testQuotaCacheAccessor(), BTreeReadersTest::testReaders(), SegStreamTest::testReadSeg(), BTreeTest::testScan(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), LogicalTxnTest::testTxnIdSequence(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSeg(), SegStreamTest::testWriteSpillAndRead(), LbmEntryTest::testZeroBytes(), and BackupRestoreTest::verifySnapshotData().

SharedRandomAccessDevice CacheTestBase::pRandomAccessDevice [protected, inherited]

The default cached device.

Definition at line 68 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeStorage(), SegStorageTestBase::openSegmentStorage(), CacheTestBase::openStorage(), and BackupRestoreTest::restore().

uint CacheTestBase::nMemPages [protected, inherited]

Size of cache in memory pages.

Definition at line 73 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), PagingTestBase::testCacheResize(), and ExecStreamTestBase::testCaseSetUp().

uint CacheTestBase::nDiskPages [protected, inherited]

Size of device in disk pages.

Definition at line 78 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), LinearViewSegmentTest::LinearViewSegmentTest(), CacheTest::makeBlockId(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), SegStreamTest::SegStreamTest(), SnapshotSegmentTestBase::SnapshotSegmentTestBase(), SnapshotSegmentTest::testDeallocateOld(), PagingTestBase::testPrefetch(), PagingTestBase::testPrefetchBatch(), PagingTestBase::testRandomOp(), SnapshotSegmentTest::testRollback(), PagingTestBase::testSequentialOp(), and PagingTestBase::testSkipOp().

uint CacheTestBase::cbPageFull [protected, inherited]

Disk page size.

Definition at line 83 of file CacheTestBase.h.

Referenced by CacheTest::CacheTest(), CacheTestBase::CacheTestBase(), CacheTestBase::openDevice(), and SegStorageTestBase::openSegmentStorage().

DeviceId CacheTestBase::dataDeviceId [protected, inherited]

Fixed ID to assign to data device.

Definition at line 88 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::closeStorage(), CacheTest::makeBlockId(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), and PagingTestBase::testCheckpoint().

TestSuite* TestBase::pTestSuite [protected, inherited]

Boost test suite.

Definition at line 59 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

boost::shared_ptr<TestBase> TestBase::pTestObj [protected, inherited]

Definition at line 61 of file TestBase.h.

Referenced by TestBase::releaseTestSuite(), and TestBase::TestBase().

std::ofstream TestBase::traceStream [protected, inherited]

Output file stream for tracing.

Definition at line 66 of file TestBase.h.

Referenced by TestBase::notifyTrace(), TestBase::TestBase(), and TestBase::~TestBase().

StrictMutex TestBase::traceMutex [protected, inherited]

Protects traceStream.

Definition at line 71 of file TestBase.h.

Referenced by TestBase::notifyTrace().

std::string TestBase::testName [protected, inherited]

Name of test.

Definition at line 76 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), TestBase::releaseTestSuite(), TestBase::TestBase(), LhxHashTableTest::testInsert1Ka(), and LhxHashTableTest::testInsert1Kb().

TraceLevel TestBase::traceLevel [protected, inherited]

Level at which to trace test execution.

Definition at line 81 of file TestBase.h.

Referenced by TestBase::getSourceTraceLevel(), and TestBase::TestBase().

FileStatsTarget TestBase::statsTarget [protected, inherited]

Output for stats.

Definition at line 86 of file TestBase.h.

StatsTimer TestBase::statsTimer [protected, inherited]

Timer for stats collection.

Definition at line 91 of file TestBase.h.

Referenced by CacheTestBase::closeStorage(), CacheTestBase::openStorage(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCaseTearDown(), and BTreeTxnTest::testTxns().

bool TestBase::traceStdout [protected, inherited]

Copy trace output to stdout.

Definition at line 99 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::traceFile [protected, inherited]

Copy trace output to file.

Definition at line 104 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::runAll [static, protected, inherited]

Run all test cases, including the extra tests.

(static, since set by readParams())

Definition at line 110 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

std::string TestBase::runSingle [static, protected, inherited]

Run only the test case of this name.

(static, since set by readParams())

Definition at line 116 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

TestCaseGroup TestBase::defaultTests [protected, inherited]

Definition at line 139 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

TestCaseGroup TestBase::extraTests [protected, inherited]

Definition at line 140 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

ParamName TestBase::paramTestSuiteName [static, inherited]

Definition at line 143 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramTraceFileName [static, inherited]

Definition at line 144 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDictionaryFileName [static, inherited]

Definition at line 145 of file TestBase.h.

Referenced by TestBase::readParams(), SegStreamTest::testRead(), and SegStreamTest::testWrite().

ParamName TestBase::paramTraceLevel [static, inherited]

Definition at line 146 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramStatsFileName [static, inherited]

Definition at line 147 of file TestBase.h.

ParamName TestBase::paramTraceStdout [static, inherited]

Definition at line 148 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDegreeOfParallelism [static, inherited]

Definition at line 149 of file TestBase.h.

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

ConfigMap TestBase::configMap [static, inherited]

Configuration parameters.

The reason this is static is so that no constructor parameters (which burden virtual bases) are needed.

Definition at line 155 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), BTreeTxnTest::BTreeTxnTest(), CacheTestBase::CacheTestBase(), BackupRestoreTest::createSnapshotData(), DatabaseTest::DatabaseTest(), TestOptionsTest::extra(), DatabaseTest::loadDatabase(), SparseBitmapTest::openStorage(), PagingTestBase::PagingTestBase(), ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest(), RandomAccessFileDeviceTest::RandomAccessFileDeviceTest(), TestBase::readParams(), SegStorageTestBase::SegStorageTestBase(), TestOptionsTest::test1(), TestOptionsTest::test2(), BackupRestoreTest::testBackupCleanup(), TestBase::TestBase(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCheckpoint(), DatabaseTest::testCreateEmpty(), DatabaseTest::testForceTxns(), BackupRestoreTest::testHeaderBackupRestore(), SegPageEntryIterTest::testIter(), SegStreamTest::testRead(), BTreeTxnTest::testTxns(), SegStreamTest::testWrite(), ThreadedTestBase::ThreadedTestBase(), and TestBase::~TestBase().

---

The documentation for this class was generated from the following file:

• /home/pub/open/dev/fennel/lucidera/test/LbmSearchTest.cpp

---