Fennel: LbmSearchTest Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

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

Inheritance diagram for LbmSearchTest:

List of all members.

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

The available victim policy implementations.

Enumerator:

| victimTwoQ | | | -------------- | | | victimLRU | | | victimRandom | |

Definition at line 44 of file CacheTestBase.h.

Constructor & Destructor Documentation

| LbmSearchTest::LbmSearchTest | ( | | ) | [inline, explicit] | | ---------------------------- | - | | - | -------------------- |

Member Function Documentation

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().

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:

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().

00552 { 00553
00554 for (uint i = 0; i < bTreeClusters.size(); i++) { 00555 bTreeClusters[i]->segmentAccessor.reset(); 00556 } 00557 for (uint i = 0; i < bTreeBitmaps.size(); i++) { 00558 bTreeBitmaps[i]->segmentAccessor.reset(); 00559 } 00560 bTreeClusters.clear(); 00561 bTreeBitmaps.clear(); 00562 00563
00564 00565 MockProducerExecStreamParams mockParams; 00566 for (uint i = 0; i < nClusters; i++) { 00567 mockParams.outputTupleDesc.push_back(attrDesc_int64); 00568 } 00569 mockParams.nRows = nRows; 00570 00571 vector<boost::shared_ptr<ColumnGenerator > > columnGenerators; 00572 SharedInt64ColumnGenerator col; 00573 assert(repeatSeqValues.size() == nClusters); 00574 for (uint i = 0; i < repeatSeqValues.size(); i++) { 00575 col = 00576 SharedInt64ColumnGenerator( 00577 new RepeatingSeqColumnGenerator(repeatSeqValues[i])); 00578 columnGenerators.push_back(col); 00579 } 00580 mockParams.pGenerator.reset( 00581 new CompositeExecStreamGenerator(columnGenerators)); 00582 00583 ExecStreamEmbryo mockStreamEmbryo; 00584 mockStreamEmbryo.init(new MockProducerExecStream(), mockParams); 00585 mockStreamEmbryo.getStream()->setName("MockProducerExecStream"); 00586 00587
00588 00589 SplitterExecStreamParams splitterParams; 00590 ExecStreamEmbryo splitterStreamEmbryo; 00591 splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams); 00592 splitterStreamEmbryo.getStream()->setName("ClusterSplitterExecStream"); 00593 00594
00595 00596 vector lcsAppendEmbryos; 00597 for (uint i = 0; i < nClusters; i++) { 00598 LcsClusterAppendExecStreamParams lcsAppendParams; 00599 boost::shared_ptr pBTreeDesc = 00600 boost::shared_ptr (new BTreeDescriptor()); 00601 bTreeClusters.push_back(pBTreeDesc); 00602 00603
00604
00605 (lcsAppendParams.tupleDesc).push_back(attrDesc_int64); 00606 (lcsAppendParams.tupleDesc).push_back(attrDesc_int64); 00607 00608
00609 (lcsAppendParams.keyProj).push_back(0); 00610 00611 initBTreeExecStreamParam(lcsAppendParams, pBTreeDesc); 00612 00613
00614 lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64); 00615 lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64); 00616 00617 lcsAppendParams.inputProj.push_back(i); 00618 00619
00620 00621 if (newRoot) { 00622 BTreeBuilder builder(*pBTreeDesc, pRandomSegment); 00623 builder.createEmptyRoot(); 00624 savedBTreeClusterRootIds.push_back(builder.getRootPageId()); 00625 } 00626 lcsAppendParams.rootPageId = pBTreeDesc->rootPageId = 00627 savedBTreeClusterRootIds[i]; 00628 00629
00630 00631 ExecStreamEmbryo lcsAppendStreamEmbryo; 00632 lcsAppendStreamEmbryo.init( 00633 new LcsClusterAppendExecStream(), lcsAppendParams); 00634 std::ostringstream oss; 00635 oss << "LcsClusterAppendExecStream" << "#" << i; 00636 lcsAppendStreamEmbryo.getStream()->setName(oss.str()); 00637 lcsAppendEmbryos.push_back(lcsAppendStreamEmbryo); 00638 } 00639 00640
00641 00642 BarrierExecStreamParams barrierParams; 00643 barrierParams.outputTupleDesc.push_back(attrDesc_int64); 00644 barrierParams.outputTupleDesc.push_back(attrDesc_int64); 00645 barrierParams.returnMode = BARRIER_RET_ANY_INPUT; 00646 00647 ExecStreamEmbryo clusterBarrierStreamEmbryo; 00648 clusterBarrierStreamEmbryo.init(new BarrierExecStream(), barrierParams); 00649 clusterBarrierStreamEmbryo.getStream()->setName("ClusterBarrierExecStream"); 00650 00651
00652 prepareDAG( 00653 mockStreamEmbryo, splitterStreamEmbryo, lcsAppendEmbryos, 00654 clusterBarrierStreamEmbryo, false); 00655 00656
00657 00658 splitterStreamEmbryo.init( 00659 new SplitterExecStream(), splitterParams); 00660 splitterStreamEmbryo.getStream()->setName("BitmapSplitterExecStream"); 00661 00662
00663
00664 00665 std::vector<std::vector > createBitmapStreamList; 00666 std::vector createBitmapStream; 00667 00668
00669 00670 LbmGeneratorExecStreamParams generatorParams; 00671 struct LcsClusterScanDef clusterScanDef; 00672 clusterScanDef.clusterTupleDesc.push_back(attrDesc_int64); 00673 00674 for (uint j = 0; j < nClusters; j++) { 00675 initClusterScanDef(generatorParams, clusterScanDef, j); 00676 } 00677 00678 TupleProjection proj; 00679 for (uint j = 0; j < nClusters; j++) { 00680 proj.push_back(j); 00681 } 00682 generatorParams.outputProj = proj; 00683 generatorParams.insertRowCountParamId = DynamicParamId(1); 00684 generatorParams.createIndex = false; 00685 00686 boost::shared_ptr pBTreeDesc = 00687 boost::shared_ptr (new BTreeDescriptor()); 00688 bTreeBitmaps.push_back(pBTreeDesc); 00689 00690
00691
00692 uint nKeys = nClusters; 00693 initBTreeTupleDesc(generatorParams.outputTupleDesc, nKeys); 00694 00695 initBTreeBitmapDesc( 00696 generatorParams.tupleDesc, generatorParams.keyProj, nKeys); 00697 initBTreeExecStreamParam(generatorParams, pBTreeDesc); 00698 00699
00700 00701 if (newRoot) { 00702 BTreeBuilder builder(*pBTreeDesc, pRandomSegment); 00703 builder.createEmptyRoot(); 00704 savedBTreeBitmapRootIds.push_back(builder.getRootPageId()); 00705 } 00706 generatorParams.rootPageId = pBTreeDesc->rootPageId = 00707 savedBTreeBitmapRootIds[0]; 00708 00709 ExecStreamEmbryo generatorStreamEmbryo; 00710 generatorStreamEmbryo.init( 00711 new LbmGeneratorExecStream(), generatorParams); 00712 std::ostringstream oss; 00713 oss << "LbmGeneratorExecStream" << "#" << 0; 00714 generatorStreamEmbryo.getStream()->setName(oss.str()); 00715 createBitmapStream.push_back(generatorStreamEmbryo); 00716 00717
00718 00719 ExternalSortExecStreamParams sortParams; 00720 initBTreeBitmapDesc( 00721 sortParams.outputTupleDesc, sortParams.keyProj, nKeys); 00722 sortParams.distinctness = DUP_ALLOW; 00723 sortParams.pTempSegment = pRandomSegment; 00724 sortParams.pCacheAccessor = pCache; 00725 sortParams.scratchAccessor = 00726 pSegmentFactory->newScratchSegment(pCache, 10); 00727 sortParams.storeFinalRun = false; 00728 sortParams.estimatedNumRows = MAXU; 00729 sortParams.earlyClose = false; 00730 00731 ExecStreamEmbryo sortStreamEmbryo; 00732 sortStreamEmbryo.init( 00733 ExternalSortExecStream::newExternalSortExecStream(), sortParams); 00734 sortStreamEmbryo.getStream()->setName("ExternalSortExecStream"); 00735 std::ostringstream oss2; 00736 oss2 << "ExternalSortExecStream" << "#" << 0; 00737 sortStreamEmbryo.getStream()->setName(oss2.str()); 00738 createBitmapStream.push_back(sortStreamEmbryo); 00739 00740
00741 00742 LbmSplicerExecStreamParams splicerParams; 00743 splicerParams.createNewIndex = false; 00744 splicerParams.scratchAccessor = 00745 pSegmentFactory->newScratchSegment(pCache, 15); 00746 splicerParams.pCacheAccessor = pCache; 00747 BTreeParams bTreeParams; 00748 initBTreeBitmapDesc( 00749 bTreeParams.tupleDesc, bTreeParams.keyProj, nKeys); 00750 initBTreeParam(bTreeParams, pBTreeDesc); 00751 bTreeParams.rootPageId = pBTreeDesc->rootPageId; 00752 splicerParams.bTreeParams.push_back(bTreeParams); 00753 splicerParams.insertRowCountParamId = DynamicParamId(1); 00754 splicerParams.writeRowCountParamId = DynamicParamId(0); 00755 splicerParams.outputTupleDesc.push_back(attrDesc_int64); 00756 00757 ExecStreamEmbryo splicerStreamEmbryo; 00758 splicerStreamEmbryo.init(new LbmSplicerExecStream(), splicerParams); 00759 std::ostringstream oss3; 00760 oss3 << "LbmSplicerExecStream" << "#" << 0; 00761 splicerStreamEmbryo.getStream()->setName(oss3.str()); 00762 createBitmapStream.push_back(splicerStreamEmbryo); 00763 00764
00765
00766 createBitmapStreamList.push_back(createBitmapStream); 00767 00768
00769 00770 barrierParams.outputTupleDesc.clear(); 00771 barrierParams.outputTupleDesc.push_back(attrDesc_int64); 00772 00773 ExecStreamEmbryo barrierStreamEmbryo; 00774 barrierStreamEmbryo.init( 00775 new BarrierExecStream(), barrierParams); 00776 barrierStreamEmbryo.getStream()->setName("BitmapBarrierExecStream"); 00777 00778
00779
00780 SharedExecStream pOutputStream = prepareDAG( 00781 clusterBarrierStreamEmbryo, splitterStreamEmbryo, 00782 createBitmapStreamList, barrierStreamEmbryo, true, false); 00783 00784
00785 RampExecStreamGenerator expectedResultGenerator(mockParams.nRows); 00786 00787 verifyOutput(*pOutputStream, 1, expectedResultGenerator); 00788 }

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

Parameters:

Definition at line 389 of file LbmSearchTest.cpp.

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

Referenced by testMultipleRanges(), and testScans().

00392 { 00393
00394 uint nInputTuples = 1; 00395 boost::scoped_array vals; 00396 char lowerDirective; 00397 char upperDirective; 00398 TupleAccessor inputTupleAccessor; 00399 TupleData inputTupleData; 00400 boost::shared_array inputBuffer; 00401 00402 initEqualSearch( 00403 nKeys, nInputTuples, vals, lowerDirective, upperDirective, 00404 inputTupleAccessor, inputTupleData, inputBuffer, useDynamicKeys); 00405 00406
00407 uint skipRows = 1; 00408 for (uint i = 0; i < nKeys; i++) { 00409 skipRows *= repeatSeqValues[i]; 00410 } 00411 for (uint i = 0; i < skipRows; i++) { 00412
00413 for (uint j = 0; j < nKeys; j++) { 00414 vals[j] = i % repeatSeqValues[j]; 00415 } 00416 inputTupleAccessor.marshal(inputTupleData, inputBuffer.get()); 00417 00418
00419 boost::scoped_array expectedBitmaps; 00420 uint bufferSize = (nRows / skipRows + 1) * 16; 00421 expectedBitmaps.reset(new FixedBuffer[bufferSize]); 00422 uint expectedNBitmaps = 0; 00423 uint expectedBufSize = 0; 00424 generateBitmaps( 00425 nRows, i, skipRows, expectedBitmaps.get(), expectedBufSize, 00426 bufferSize, expectedNBitmaps); 00427 00428 testScanIdx( 00429 nKeys, nKeys, inputTupleAccessor.getCurrentByteCount(), 00430 inputBuffer, expectedNBitmaps, expectedBitmaps.get(), false, 00431 useDynamicKeys, includeRid, vals); 00432 } 00433 }

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

Parameters:

Definition at line 435 of file LbmSearchTest.cpp.

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

Referenced by testScans().

00437 { 00438
00439 uint nInputTuples = 1; 00440 boost::scoped_array vals; 00441 char lowerDirective; 00442 char upperDirective; 00443 TupleAccessor inputTupleAccessor; 00444 TupleData inputTupleData; 00445 boost::shared_array inputBuffer; 00446 00447 initEqualSearch( 00448 nKeys - 1, nInputTuples, vals, lowerDirective, upperDirective, 00449 inputTupleAccessor, inputTupleData, inputBuffer, false); 00450 00451
00452 for (uint j = 0; j < nKeys - 1; j++) { 00453 vals[j] = 0; 00454 } 00455 inputTupleAccessor.marshal(inputTupleData, inputBuffer.get()); 00456 00457
00458
00459
00460
00461 00462 uint skipRows = 1; 00463 for (uint i = 0; i < nKeys - 1; i++) { 00464 skipRows *= repeatSeqValues[i]; 00465 } 00466 boost::scoped_array expectedBitmaps; 00467 uint bufferSize = (nRows / skipRows / 8 + 1) 00468 * 12 * repeatSeqValues[nKeys - 1]; 00469 expectedBitmaps.reset(new FixedBuffer[bufferSize]); 00470 PBuffer bitmapBuf = expectedBitmaps.get(); 00471 uint expectedNBitmaps = 0; 00472 uint curBufSize = 0; 00473 00474 for (uint i = 0; i < repeatSeqValues[nKeys - 1]; i++) { 00475 uint start; 00476 if (i == 0) { 00477 start = 0; 00478 } else { 00479
00480
00481 for (start = i; start < nRows; 00482 start += repeatSeqValues[nKeys - 1]) 00483 { 00484 uint j; 00485 for (j = 0; j < nKeys - 1; j++) { 00486 if (start % repeatSeqValues[j] != 0) { 00487 break; 00488 } 00489 } 00490 if (j == nKeys - 1) { 00491 break; 00492 } 00493 } 00494 if (start >= nRows) { 00495 continue; 00496 } 00497 } 00498 generateBitmaps( 00499 nRows, start, skipRows * repeatSeqValues[nKeys - 1], 00500 bitmapBuf, curBufSize, bufferSize, expectedNBitmaps); 00501 } 00502 testScanIdx( 00503 nKeys, nKeys - 1, inputTupleAccessor.getCurrentByteCount(), 00504 inputBuffer, expectedNBitmaps, bitmapBuf, false, false, false, vals); 00505 }

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

Parameters:

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().

00890 { 00891 resetExecStreamTest(); 00892 00893
00894
00895 00896 ValuesExecStreamParams valuesParams; 00897 for (uint i = 0; i < 2; i++) { 00898 valuesParams.outputTupleDesc.push_back(attrDesc_char1); 00899 for (uint j = 0; j < nKeys; j++) { 00900 valuesParams.outputTupleDesc.push_back(attrDesc_nullableInt64); 00901 } 00902 } 00903 valuesParams.pTupleBuffer = inputBuffer; 00904 valuesParams.bufSize = bufSize; 00905 00906 ExecStreamEmbryo valuesStreamEmbryo; 00907 valuesStreamEmbryo.init(new ValuesExecStream(), valuesParams); 00908 valuesStreamEmbryo.getStream()->setName("ValuesExecStream"); 00909 00910
00911 00912 LbmSearchExecStreamParams indexScanParams; 00913 00914
00915 indexScanParams.rowLimitParamId = DynamicParamId(0); 00916 if (includeRid) { 00917 indexScanParams.startRidParamId = DynamicParamId(1); 00918 SharedDynamicParamManager pDynamicParamManager = 00919 pGraph->getDynamicParamManager(); 00920 pDynamicParamManager->createParam(DynamicParamId(1), attrDesc_int64); 00921 TupleDatum ridDatum; 00922 LcsRid rid = LcsRid(0); 00923 ridDatum.pData = (PConstBuffer) &rid; 00924 ridDatum.cbData = sizeof(LcsRid); 00925 pDynamicParamManager->writeParam(DynamicParamId(1), ridDatum); 00926 } else { 00927 indexScanParams.startRidParamId = DynamicParamId(0); 00928 } 00929 00930
00931 initBTreeBitmapDesc( 00932 indexScanParams.tupleDesc, indexScanParams.keyProj, totalKeys); 00933 initBTreeExecStreamParam(indexScanParams, bTreeBitmaps[0]); 00934 bTreeBitmaps[0]->rootPageId = savedBTreeBitmapRootIds[0]; 00935 00936 if (!dynamicRootPageId) { 00937 indexScanParams.rootPageId = savedBTreeBitmapRootIds[0]; 00938 } else { 00939 indexScanParams.rootPageId = NULL_PAGE_ID; 00940 indexScanParams.rootPageIdParamId = DynamicParamId(2); 00941 SharedDynamicParamManager pDynamicParamManager = 00942 pGraph->getDynamicParamManager(); 00943 pDynamicParamManager->createParam(DynamicParamId(2), attrDesc_int64); 00944 TupleDatum rootPageIdDatum; 00945 rootPageIdDatum.pData = (PConstBuffer) &(savedBTreeBitmapRootIds[0]); 00946 rootPageIdDatum.cbData = sizeof(PageId); 00947 pDynamicParamManager->writeParam(DynamicParamId(2), rootPageIdDatum); 00948 } 00949 00950 TupleProjection outputProj; 00951 for (uint i = totalKeys; i < totalKeys + 3; i++) { 00952 outputProj.push_back(i); 00953 } 00954 indexScanParams.outputProj = outputProj; 00955 00956
00957 indexScanParams.outerJoin = false; 00958 TupleProjection inputKeyProj; 00959 for (uint i = 0; i < 2; i++) { 00960 for (uint j = 0; j < nKeys; j++) { 00961 inputKeyProj.push_back(i * (nKeys + 1) + j + 1); 00962 } 00963 } 00964 indexScanParams.inputKeyProj = inputKeyProj; 00965 indexScanParams.inputDirectiveProj.push_back(0); 00966 indexScanParams.inputDirectiveProj.push_back(nKeys + 1); 00967 00968
00969 indexScanParams.outputTupleDesc = bitmapTupleDesc; 00970 00971 if (useDynamicKeys) { 00972 SharedDynamicParamManager pDynamicParamManager = 00973 pGraph->getDynamicParamManager(); 00974 for (uint i = 3; i < nKeys * 2 + 3; i++) { 00975 indexScanParams.searchKeyParams.push_back( 00976 BTreeSearchKeyParameter( 00977 DynamicParamId(i), 00978 i - 3)); 00979 pDynamicParamManager->createParam( 00980 DynamicParamId(i), attrDesc_int64); 00981 TupleDatum keyValDatum; 00982 keyValDatum.pData = (PConstBuffer) &(vals[(i - 3) % nKeys]); 00983 keyValDatum.cbData = sizeof(uint64_t); 00984 pDynamicParamManager->writeParam(DynamicParamId(i), keyValDatum); 00985 } 00986 } 00987 00988 ExecStreamEmbryo indexScanStreamEmbryo; 00989 indexScanStreamEmbryo.init(new LbmSearchExecStream(), indexScanParams); 00990 indexScanStreamEmbryo.getStream()->setName("IndexScanStream"); 00991 00992 SharedExecStream pOutputStream = prepareTransformGraph( 00993 valuesStreamEmbryo, indexScanStreamEmbryo); 00994 00995 bitmapTupleAccessor.setCurrentTupleBuf(expectedBitmaps); 00996 verifyBufferedOutput( 00997 *pOutputStream, bitmapTupleDesc, expectedNBitmaps, expectedBitmaps); 00998 }

Initializes input search key and directives for an equality search.

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().

00513 { 00514 TupleDescriptor inputTupleDesc; 00515 for (uint i = 0; i < 2; i++) { 00516 inputTupleDesc.push_back(attrDesc_char1); 00517 for (uint j = 0; j < nKeys; j++) { 00518 inputTupleDesc.push_back(attrDesc_nullableInt64); 00519 } 00520 } 00521 00522 inputTupleData.compute(inputTupleDesc); 00523 00524 vals.reset(new uint64_t[nKeys]); 00525 lowerDirective = '['; 00526 inputTupleData[0].pData = (PConstBuffer) &lowerDirective; 00527 upperDirective = ']'; 00528 inputTupleData[nKeys + 1].pData = (PConstBuffer) &upperDirective; 00529 for (uint i = 0; i < nKeys; i++) { 00530
00531
00532 if (useDynamicKeys) { 00533 inputTupleData[i + 1].pData = NULL; 00534 inputTupleData[i + 1].cbData = 0; 00535 inputTupleData[nKeys + 1 + i + 1].pData = NULL; 00536 inputTupleData[nKeys + 1 + i + 1].cbData = 0; 00537 } else { 00538 inputTupleData[i + 1].pData = (PConstBuffer) &vals[i]; 00539 inputTupleData[nKeys + 1 + i + 1].pData = (PConstBuffer) &vals[i]; 00540 } 00541 } 00542 00543 inputTupleAccessor.compute(inputTupleDesc); 00544 00545 inputBuffer.reset( 00546 new FixedBuffer[nInputTuples * inputTupleAccessor.getMaxByteCount()]); 00547 }

| void LbmSearchTest::testCaseSetUp | ( | | ) | [virtual] | | --------------------------------- | - | | - | ----------- |

| void LbmSearchTest::testCaseTearDown | ( | | ) | [virtual] | | ------------------------------------ | - | | - | ----------- |

Definition at line 264 of file LbmSearchTest.cpp.

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

Referenced by testScanOneLevel(), and testScanTwoLevel().

00265 { 00266 uint nClusters = 3; 00267 std::vector repeatSeqValues; 00268 00269
00270 repeatSeqValues.push_back(1); 00271 repeatSeqValues.push_back(5); 00272 repeatSeqValues.push_back(9); 00273 loadTableAndIndex(nRows, nClusters, repeatSeqValues, true); 00274 00275
00276
00277
00278 testScanFullKey(nRows, nClusters, repeatSeqValues, false, false); 00279 testScanFullKey(nRows, nClusters, repeatSeqValues, true, false); 00280 testScanFullKey(nRows, nClusters, repeatSeqValues, false, true); 00281 00282
00283 testScanPartialKey(nRows, nClusters, repeatSeqValues); 00284 }

| void LbmSearchTest::testScanOneLevel | ( | | ) | | ------------------------------------ | - | | - |

| void LbmSearchTest::testScanTwoLevel | ( | | ) | | ------------------------------------ | - | | - |

| 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().

00287 { 00288 uint nRows = 20000; 00289 uint nClusters = 1; 00290 std::vector repeatSeqValues; 00291 00292
00293 repeatSeqValues.push_back(100); 00294 loadTableAndIndex(nRows, nClusters, repeatSeqValues, true); 00295 00296
00297 testScanFullKey(nRows, nClusters, repeatSeqValues, false, false); 00298 00299 resetExecStreamTest(); 00300 00301
00302
00303
00304
00305
00306
00307 00308 TupleDescriptor inputTupleDesc; 00309 for (uint i = 0; i < 2; i++) { 00310 inputTupleDesc.push_back(attrDesc_char1); 00311 inputTupleDesc.push_back(attrDesc_nullableInt64); 00312 } 00313 TupleData inputTupleData(inputTupleDesc); 00314 TupleAccessor inputTupleAccessor; 00315 inputTupleAccessor.compute(inputTupleDesc); 00316 00317 uint nInputTuples = 4; 00318 boost::shared_array inputBuffer; 00319 inputBuffer.reset( 00320 new FixedBuffer[nInputTuples * inputTupleAccessor.getMaxByteCount()]); 00321 PBuffer inputBuf = inputBuffer.get(); 00322 uint offset = 0; 00323 00324 setSearchKey( 00325 '-', ')', 0, 8, inputBuf, offset, inputTupleAccessor, inputTupleData); 00326 setSearchKey( 00327 '(', ']', 10, 17, inputBuf, offset, inputTupleAccessor, 00328 inputTupleData); 00329 setSearchKey( 00330 '[', ')', 44, 60, inputBuf, offset, inputTupleAccessor, 00331 inputTupleData); 00332 setSearchKey( 00333 '(', '+', 71, 0, inputBuf, offset, inputTupleAccessor, 00334 inputTupleData); 00335 00336
00337 boost::scoped_array expectedBitmaps; 00338 uint bufferSize = ((nRows / repeatSeqValues[0] / 8 + 1) * 60) * 24; 00339 expectedBitmaps.reset(new FixedBuffer[bufferSize]); 00340 PBuffer bitmapBuf = expectedBitmaps.get(); 00341 uint expectedNBitmaps = 0; 00342 uint expectedBufSize = 0; 00343
00344
00345 for (uint i = 0; i < 8; i++) { 00346 generateBitmaps( 00347 nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize, 00348 bufferSize, expectedNBitmaps); 00349 } 00350 for (uint i = 11; i <= 17; i++) { 00351 generateBitmaps( 00352 nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize, 00353 bufferSize, expectedNBitmaps); 00354 } 00355 for (uint i = 44; i < 60; i++) { 00356 generateBitmaps( 00357 nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize, 00358 bufferSize, expectedNBitmaps); 00359 } 00360 for (uint i = 72; i < repeatSeqValues[0]; i++) { 00361 generateBitmaps( 00362 nRows, i, repeatSeqValues[0], bitmapBuf, expectedBufSize, 00363 bufferSize, expectedNBitmaps); 00364 } 00365 00366 boost::scoped_array vals; 00367 testScanIdx( 00368 nClusters, nClusters, offset, inputBuffer, expectedNBitmaps, 00369 bitmapBuf, true, false, false, vals); 00370 }

| static const std::string& LbmExecStreamTestBase::getTraceName | ( | | ) | [inline, static, 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().

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

Parameters:

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().

00166 { 00167 LbmEntry lbmEntry; 00168 boost::scoped_array entryBuf; 00169 LcsRid rid = LcsRid(start); 00170 00171
00172 uint scratchBufSize = LbmEntry::getScratchBufferSize(bitmapColSize); 00173 entryBuf.reset(new FixedBuffer[scratchBufSize]); 00174 lbmEntry.init(entryBuf.get(), NULL, scratchBufSize, bitmapTupleDesc); 00175 bitmapTupleData[0].pData = (PConstBuffer) &rid; 00176 lbmEntry.setEntryTuple(bitmapTupleData); 00177 00178
00179 for (rid = LcsRid(start + skipRows); rid < LcsRid(nRows); rid += skipRows) { 00180 if (!lbmEntry.setRID(LcsRid(rid))) { 00181
00182
00183 produceEntry( 00184 lbmEntry, bitmapTupleAccessor, 00185 pBuf, bufSize, nBitmaps, includeKeys); 00186 lbmEntry.setEntryTuple(bitmapTupleData); 00187 } 00188 } 00189
00190 produceEntry( 00191 lbmEntry, bitmapTupleAccessor, pBuf, bufSize, nBitmaps, includeKeys); 00192 00193 assert(bufSize <= fullBufSize); 00194 }

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().

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().

Calculates size of result bitmap.

Parameters:

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().

Definition at line 344 of file LbmExecStreamTestBase.h.

00345 { 00346
00347
00348
00349 uint extraSpace = 16; 00350 return (nRids / 8) + extraSpace; 00351 }

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().

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

Parameters:

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().

00051 { 00052 std::vector transforms; 00053 transforms.push_back(transformStreamEmbryo); 00054 return prepareTransformGraph(sourceStreamEmbryo, transforms); 00055 }

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

Parameters:

Returns:

output buffer stream

Definition at line 57 of file ExecStreamUnitTestBase.cpp.

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

00060 { 00061 pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryo); 00062 std::vector::iterator it; 00063 00064
00065 for (it = transforms.begin(); it != transforms.end(); ++it) { 00066 pGraphEmbryo->saveStreamEmbryo(*it); 00067 } 00068 00069
00070 ExecStreamEmbryo& previousStream = sourceStreamEmbryo; 00071 for (it = transforms.begin(); it != transforms.end(); ++it) { 00072 pGraphEmbryo->addDataflow( 00073 previousStream.getStream()->getName(), 00074 (*it).getStream()->getName()); 00075 previousStream = *it; 00076 } 00077 00078 SharedExecStream pAdaptedStream = 00079 pGraphEmbryo->addAdapterFor( 00080 previousStream.getStream()->getName(), 00081 0, 00082 BUFPROV_PRODUCER); 00083 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00084 00085 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00086 return pAdaptedStream; 00087 }

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

Parameters:

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().

00093 { 00094 std::vector sourceStreamEmbryos; 00095 sourceStreamEmbryos.push_back(sourceStreamEmbryo1); 00096 sourceStreamEmbryos.push_back(sourceStreamEmbryo2); 00097 return prepareConfluenceGraph(sourceStreamEmbryos, confluenceStreamEmbryo); 00098 }

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

Parameters:

Returns:

output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

00158 { 00159 std::vector<std::vector > sourceStreamEmbryosList; 00160 std::vector::iterator it; 00161 std::vector sourceStreamList; 00162 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00163 it++) 00164 { 00165 sourceStreamList.clear(); 00166 sourceStreamList.push_back(*it); 00167 sourceStreamEmbryosList.push_back(sourceStreamList); 00168 } 00169 00170 return 00171 prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo); 00172 }

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:

Returns:

output buffer stream

Definition at line 174 of file ExecStreamUnitTestBase.cpp.

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

00177 { 00178 pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo); 00179 00180 for (int i = 0; i < sourceStreamEmbryosList.size(); i++) { 00181 for (int j = 0; j < sourceStreamEmbryosList[i].size(); j++) { 00182 pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryosList[i][j]); 00183 } 00184 00185
00186 for (int j = 1; j < sourceStreamEmbryosList[i].size(); j++) { 00187 pGraphEmbryo->addDataflow( 00188 sourceStreamEmbryosList[i][j - 1].getStream()->getName(), 00189 sourceStreamEmbryosList[i][j].getStream()->getName()); 00190 } 00191 pGraphEmbryo->addDataflow( 00192 sourceStreamEmbryosList[i].back().getStream()->getName(), 00193 confluenceStreamEmbryo.getStream()->getName()); 00194 } 00195 00196 SharedExecStream pAdaptedStream = 00197 pGraphEmbryo->addAdapterFor( 00198 confluenceStreamEmbryo.getStream()->getName(), 0, 00199 BUFPROV_PRODUCER); 00200 pGraph->addOutputDataflow( 00201 pAdaptedStream->getStreamId()); 00202 00203 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00204 00205 return pAdaptedStream; 00206 }

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

Parameters:

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().

00105 { 00106 std::vector sourceStreamEmbryos; 00107 sourceStreamEmbryos.push_back(sourceStreamEmbryo1); 00108 sourceStreamEmbryos.push_back(sourceStreamEmbryo2); 00109 00110 std::vector::iterator it; 00111 00112 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00113 ++it) 00114 { 00115 pGraphEmbryo->saveStreamEmbryo(*it); 00116 } 00117 pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo); 00118 00119 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00120 ++it) 00121 { 00122 pGraphEmbryo->addDataflow( 00123 (*it).getStream()->getName(), 00124 confluenceStreamEmbryo.getStream()->getName()); 00125 } 00126 00127 std::vector transforms; 00128 transforms.push_back(transformStreamEmbryo); 00129 ExecStreamEmbryo& previousStream = confluenceStreamEmbryo; 00130 00131
00132 for (it = transforms.begin(); it != transforms.end(); ++it) { 00133 pGraphEmbryo->saveStreamEmbryo(*it); 00134 } 00135 00136 for (it = transforms.begin(); it != transforms.end(); ++it) { 00137 pGraphEmbryo->addDataflow( 00138 previousStream.getStream()->getName(), 00139 (*it).getStream()->getName()); 00140 previousStream = *it; 00141 } 00142 00143 00144 SharedExecStream pAdaptedStream = 00145 pGraphEmbryo->addAdapterFor( 00146 previousStream.getStream()->getName(), 00147 0, 00148 BUFPROV_PRODUCER); 00149 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00150 00151 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00152 return pAdaptedStream; 00153 }

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:

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().

00215 { 00216 std::vector<std::vector > listOfList; 00217 00218
00219
00220
00221 for (uint i = 0; i < interStreamEmbryos.size(); i++) { 00222 std::vector interStreamEmbryoList; 00223 00224 interStreamEmbryoList.push_back(interStreamEmbryos[i]); 00225 listOfList.push_back(interStreamEmbryoList); 00226 } 00227 return prepareDAG( 00228 srcStreamEmbryo, splitterStreamEmbryo, listOfList, destStreamEmbryo, 00229 createSink, saveSrc); 00230 }

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:

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.

00239 { 00240 if (saveSrc) { 00241 pGraphEmbryo->saveStreamEmbryo(srcStreamEmbryo); 00242 } 00243 pGraphEmbryo->saveStreamEmbryo(splitterStreamEmbryo); 00244 00245
00246 for (int i = 0; i < interStreamEmbryos.size(); i++) { 00247 for (int j = 0; j < interStreamEmbryos[i].size(); j++) { 00248 pGraphEmbryo->saveStreamEmbryo(interStreamEmbryos[i][j]); 00249 } 00250 00251
00252 for (int j = 1; j < interStreamEmbryos[i].size(); j++) { 00253 pGraphEmbryo->addDataflow( 00254 interStreamEmbryos[i][j - 1].getStream()->getName(), 00255 interStreamEmbryos[i][j].getStream()->getName()); 00256 } 00257 } 00258 00259 pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo); 00260 00261 pGraphEmbryo->addDataflow( 00262 srcStreamEmbryo.getStream()->getName(), 00263 splitterStreamEmbryo.getStream()->getName()); 00264 00265
00266 for (int i = 0; i < interStreamEmbryos.size(); i++) { 00267 pGraphEmbryo->addDataflow( 00268 splitterStreamEmbryo.getStream()->getName(), 00269 interStreamEmbryos[i][0].getStream()->getName()); 00270 pGraphEmbryo->addDataflow( 00271 interStreamEmbryos[i].back().getStream()->getName(), 00272 destStreamEmbryo.getStream()->getName()); 00273 } 00274 00275 SharedExecStream pAdaptedStream; 00276 00277 if (createSink) { 00278 pAdaptedStream = pGraphEmbryo->addAdapterFor( 00279 destStreamEmbryo.getStream()->getName(), 0, 00280 BUFPROV_PRODUCER); 00281 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00282 00283 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00284 } 00285 00286 return pAdaptedStream; 00287 }

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

Parameters:

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().

00330 { 00331
00332 00333 pResourceGovernor->requestResources(*pGraph); 00334 pGraph->open(); 00335 pScheduler->start(); 00336 uint nRows = 0; 00337 for (;;) { 00338 ExecStreamBufAccessor &bufAccessor = 00339 pScheduler->readStream(stream); 00340 if (bufAccessor.getState() == EXECBUF_EOS) { 00341 break; 00342 } 00343 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00344 const uint nCol = 00345 bufAccessor.getConsumptionTupleAccessor().size(); 00346 BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size()); 00347 BOOST_REQUIRE(nCol >= 1); 00348 TupleData inputTuple; 00349 inputTuple.compute(bufAccessor.getTupleDesc()); 00350 for (;;) { 00351 if (!bufAccessor.demandData()) { 00352 break; 00353 } 00354 BOOST_REQUIRE(nRows < nRowsExpected); 00355 bufAccessor.unmarshalTuple(inputTuple); 00356 for (int col = 0; col < nCol; ++col) { 00357 int64_t actualValue = 00358 *reinterpret_cast<int64_t const *>(inputTuple[col].pData); 00359 int64_t expectedValue = generator.generateValue(nRows, col); 00360 if (actualValue != expectedValue) { 00361 std::cout << "(Row, Col) = (" << nRows << ", " << col <<")" 00362 << std::endl; 00363 BOOST_CHECK_EQUAL(expectedValue,actualValue); 00364 return; 00365 } 00366 } 00367 bufAccessor.consumeTuple(); 00368 ++nRows; 00369 if (stopEarly && nRows == nRowsExpected) { 00370 return; 00371 } 00372 } 00373 } 00374 BOOST_CHECK_EQUAL(nRowsExpected,nRows); 00375 }

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

Parameters:

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().

00381 { 00382
00383 00384 pResourceGovernor->requestResources(*pGraph); 00385 pGraph->open(); 00386 pScheduler->start(); 00387 uint nRows = 0; 00388 for (;;) { 00389 ExecStreamBufAccessor &bufAccessor = 00390 pScheduler->readStream(stream); 00391 if (bufAccessor.getState() == EXECBUF_EOS) { 00392 break; 00393 } 00394 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00395 00396 if (!bufAccessor.demandData()) { 00397 break; 00398 } 00399 BOOST_REQUIRE(nRows < nRowsExpected); 00400 00401 TupleData actualTuple; 00402 actualTuple.compute(bufAccessor.getTupleDesc()); 00403 bufAccessor.unmarshalTuple(actualTuple); 00404 00405 int c = bufAccessor.getTupleDesc().compareTuples( 00406 expectedTuple, actualTuple); 00407 bufAccessor.consumeTuple(); 00408 ++nRows; 00409 if (c) { 00410 #if 1 00411 TupleDescriptor statusDesc = bufAccessor.getTupleDesc(); 00412 TuplePrinter tuplePrinter; 00413 tuplePrinter.print(std::cout, statusDesc, actualTuple); 00414 tuplePrinter.print(std::cout, statusDesc, expectedTuple); 00415 std::cout << std::endl; 00416 #endif 00417 BOOST_CHECK_EQUAL(0,c); 00418 break; 00419 } 00420 } 00421 BOOST_CHECK_EQUAL(nRowsExpected, nRows); 00422 }

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

Parameters:

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().

00429 { 00430
00431 00432 TupleAccessor expectedOutputAccessor; 00433 expectedOutputAccessor.compute(outputTupleDesc); 00434 TupleData expectedTuple(outputTupleDesc); 00435 uint bufOffset = 0; 00436 pResourceGovernor->requestResources(*pGraph); 00437 pGraph->open(); 00438 pScheduler->start(); 00439 uint nRows = 0; 00440 for (;;) { 00441 ExecStreamBufAccessor &bufAccessor = 00442 pScheduler->readStream(stream); 00443 if (bufAccessor.getState() == EXECBUF_EOS) { 00444 break; 00445 } 00446 BOOST_REQUIRE(bufAccessor.getTupleDesc() == outputTupleDesc); 00447 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00448 const uint nCol = 00449 bufAccessor.getConsumptionTupleAccessor().size(); 00450 BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size()); 00451 BOOST_REQUIRE(nCol >= 1); 00452 TupleData inputTuple; 00453 inputTuple.compute(bufAccessor.getTupleDesc()); 00454 for (;;) { 00455 if (!bufAccessor.demandData()) { 00456 break; 00457 } 00458 BOOST_REQUIRE(nRows < nRowsExpected); 00459 bufAccessor.unmarshalTuple(inputTuple); 00460 expectedOutputAccessor.setCurrentTupleBuf( 00461 expectedBuffer + bufOffset); 00462 expectedOutputAccessor.unmarshal(expectedTuple); 00463 int c = outputTupleDesc.compareTuples(inputTuple, expectedTuple); 00464 if (c) { 00465 std::cout << "(Row) = (" << nRows << ")" 00466 << " -- Tuples don't match"<< std::endl; 00467 BOOST_CHECK_EQUAL(0,c); 00468 return; 00469 } 00470 bufAccessor.consumeTuple(); 00471 bufOffset += expectedOutputAccessor.getCurrentByteCount(); 00472 ++nRows; 00473 } 00474 } 00475 BOOST_CHECK_EQUAL(nRowsExpected,nRows); 00476 }

| 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().

| void ExecStreamUnitTestBase::tearDownExecStreamTest | ( | | ) | [protected, 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().

| void SegStorageTestBase::openRandomSegment | ( | | ) | [virtual, inherited] | | ------------------------------------------ | - | | - | ---------------------- |

| void SegStorageTestBase::closeLinearSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeRandomSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeVersionedRandomSegment | ( | | ) | [inherited] | | ---------------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeSnapshotRandomSegment | ( | | ) | [inherited] | | --------------------------------------------------- | - | | - | ------------- |

| 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().

| Cache & CacheTestBase::getCache | ( | | ) | [inherited] | | -------------------------------------------------- | - | | - | ------------- |

| SharedCache CacheTestBase::newCache | ( | | ) | [virtual, 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.

00109 { 00110 bool verbose = false; 00111 ConfigMap adhocMap; 00112 00113 for (int i = 1; i < argc; ++i) { 00114 std::string arg = argv[i]; 00115 if (argv[i][0] == '-') { 00116 if (arg == "-v") { 00117 verbose = true; 00118 } else if (arg == "-") { 00119 configMap.readParams(std::cin); 00120 } else if (arg == "-all") { 00121 runAll = true; 00122 } else if (arg == "-t") {
00123 permAssert(i + 1 < argc); 00124 runSingle = argv[++i]; 00125 } else if (arg[1] == 't') { 00126 runSingle = arg.substr(2); 00127 } 00128 } else { 00129 int i = arg.find("="); 00130 if ((0 < i) && (i < arg.size())) { 00131
00132 std::string key = arg.substr(0,i); 00133 std::string val = arg.substr(i + 1); 00134 adhocMap.setStringParam(key,val); 00135 } else { 00136
00137 std::ifstream configFile(arg.c_str()); 00138 assert(configFile.good()); 00139 configMap.readParams(configFile); 00140 } 00141 } 00142 } 00143 configMap.mergeFrom(adhocMap); 00144 00145
00146
00147 if (.isParamSet(paramDictionaryFileName)) { 00148 std::string dictFileName = "dictWords"; 00149 configMap.setStringParam(paramDictionaryFileName,dictFileName); 00150 } 00151 00152 if (verbose) { 00153 configMap.dumpParams(std::cout); 00154 } 00155 }

| TestSuite * TestBase::releaseTestSuite | ( | | ) | [inherited] | | ---------------------------------------------------------------------------------------------- | - | | - | ------------- |

Member Data Documentation

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().

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().

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().

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().

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().

(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().

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().

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().

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

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