BTreeSearchExecStream Class Reference

BTreeSearchExecStream reads keys from a child and returns matching tuples in the BTree. More...

#include <BTreeSearchExecStream.h>

Inheritance diagram for BTreeSearchExecStream:

BTreeReadExecStream ConduitExecStream BTreeExecStream SingleInputExecStream SingleOutputExecStream SingleOutputExecStream ExecStream ExecStream ExecStream ClosableObject TraceSource ErrorSource ClosableObject TraceSource ErrorSource ClosableObject TraceSource ErrorSource BTreePrefetchSearchExecStream BTreeSearchUniqueExecStream LbmSearchExecStream List of all members.

Public Member Functions

void prepare (BTreeSearchExecStreamParams const &params)
virtual void open (bool restart)
 Opens this stream, acquiring any resources needed in order to be able to fetch data.
virtual ExecStreamResult execute (ExecStreamQuantum const &quantum)
 Executes this stream.
virtual void closeImpl ()
 Implements ClosableObject.
virtual void prepare (BTreeReadExecStreamParams const &params)
virtual void prepare (BTreeExecStreamParams const &params)
virtual void prepare (SingleOutputExecStreamParams const &params)
virtual void prepare (ExecStreamParams const &params)
 Prepares this stream for execution.
virtual void getResourceRequirements (ExecStreamResourceQuantity &minQuantity, ExecStreamResourceQuantity &optQuantity)
virtual void getResourceRequirements (ExecStreamResourceQuantity &minQuantity, ExecStreamResourceQuantity &optQuantity, ExecStreamResourceSettingType &optType)
 Determines resource requirements for this stream.
virtual void setInputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &inAccessors)
 Initializes the buffer accessors for inputs to this stream.
virtual void setOutputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &outAccessors)
 Initializes the buffer accessors for outputs from this stream.
virtual ExecStreamBufProvision getOutputBufProvision () const
 Queries the BufferProvision which this stream is capable of when producing tuples.
virtual bool canEarlyClose ()
 
Returns:
true if the stream can be closed early

ExecStreamGraph & getGraph () const
 
Returns:
reference to containing graph

ExecStreamId getStreamId () const
 
Returns:
the identifier for this stream within containing graph

virtual void setResourceAllocation (ExecStreamResourceQuantity &quantity)
 Sets current resource allocation for this stream.
virtual void setName (std::string const &)
 Sets unique name of this stream.
virtual std::string const & getName () const
 
Returns:
the name of this stream, as known by the optimizer

virtual bool mayBlock () const
 Queries whether this stream's implementation may block when execute() is called.
virtual void checkAbort () const
 Checks whether there is an abort request for this stream's scheduler.
virtual ExecStreamBufProvision getOutputBufConversion () const
 Queries the BufferProvision to which this stream needs its output to be converted, if any.
virtual ExecStreamBufProvision getInputBufProvision () const
 Queries the BufferProvision which this stream requires of its inputs when consuming their tuples.
bool isClosed () const
 
Returns:
whether the object has been closed

void close ()
 Closes this object, releasing any unallocated resources.
virtual void initTraceSource (SharedTraceTarget pTraceTarget, std::string name)
 For use when initialization has to be deferred until after construction.
void trace (TraceLevel level, std::string message) const
 Records a trace message.
bool isTracing () const
 
Returns:
true iff tracing is enabled for this source

bool isTracingLevel (TraceLevel level) const
 Determines whether a particular level is being traced.
TraceTarget & getTraceTarget () const
 
Returns:
the TraceTarget for this source

SharedTraceTarget getSharedTraceTarget () const
 
Returns:
the SharedTraceTarget for this source

std::string getTraceSourceName () const
 Gets the name of this source.
void setTraceSourceName (std::string const &n)
 Sets the name of this source.
TraceLevel getMinimumTraceLevel () const
void disableTracing ()
virtual void initErrorSource (SharedErrorTarget pErrorTarget, const std::string &name)
 For use when initialization has to be deferred until after construction.
void postError (ErrorLevel level, const std::string &message, void *address, long capacity, int index)
 Posts an exception, such as a row exception.
void postError (ErrorLevel level, const std::string &message, const TupleDescriptor &errorDesc, const TupleData &errorTuple, int index)
 Posts an exception, such as a row exception.
bool hasTarget () const
 
Returns:
true iff an error target has been set

ErrorTarget & getErrorTarget () const
 
Returns:
the ErrorTarget for this source

SharedErrorTarget getSharedErrorTarget () const
 
Returns:
the SharedErrorTarget for this source

std::string getErrorSourceName () const
 Gets the name of this source.
void setErrorSourceName (std::string const &n)
 Sets the name of this source.
void disableTarget ()
virtual void setOutputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &outAccessors)
 Initializes the buffer accessors for outputs from this stream.
virtual void setInputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &inAccessors)
 Initializes the buffer accessors for inputs to this stream.
virtual void prepare (ConduitExecStreamParams const &params)
virtual void prepare (SingleInputExecStreamParams const &params)
virtual ExecStreamBufProvision getInputBufProvision () const
 Queries the BufferProvision which this stream requires of its inputs when consuming their tuples.

Static Public Member Functions

static SharedBTreeWriter newWriter (BTreeExecStreamParams const &params)
static void copyParamsToDescriptor (BTreeDescriptor &, BTreeParams const &, SharedCacheAccessor const &)

Protected Member Functions

bool innerSearchLoop ()
ExecStreamResult innerFetchLoop (ExecStreamQuantum const &quantum, uint &nTuples)
void readDirectives ()
bool testInterval ()
void readSearchKey ()
 Reads the search key either from the input stream or dynamic parameters.
void readUpperBoundKey ()
 Reads the upper bound key either from the input stream or dynamic parameters.
bool checkNextKey ()
 Determines if the next key value is within the upper bound search range.
virtual bool reachedTupleLimit (uint nTuples)
 Determines if enough tuples have been produced for this stream.
bool searchForKey ()
 Searches the btree for a specific key.
virtual SharedBTreeReader newReader ()
SharedBTreeWriter newWriter (bool monotonic=false)
virtual void endSearch ()
 Forgets the current reader or writer's search, releasing any page locks.
ExecStreamResult precheckConduitBuffers ()
 Checks the state of the input and output buffers.

Protected Attributes

TupleProjectionAccessor inputKeyAccessor
TupleProjectionAccessor inputJoinAccessor
TupleProjectionAccessor readerKeyAccessor
TupleProjectionAccessor directiveAccessor
TupleProjectionAccessor upperBoundAccessor
TupleDescriptor inputKeyDesc
TupleDescriptor upperBoundDesc
TupleData inputKeyData
TupleData upperBoundData
TupleData readerKeyData
TupleData directiveData
TupleData * pSearchKey
bool outerJoin
bool preFilterNulls
uint nJoinAttributes
SearchEndpoint lowerBoundDirective
SearchEndpoint upperBoundDirective
bool leastUpper
std::vector< BTreeSearchKeyParameter > searchKeyParams
boost::scoped_array< FixedBuffer > searchKeyBuffer
bool dynamicKeysRead
TupleProjection searchKeyProj
TupleProjection upperBoundKeyProj
SharedBTreeReader pReader
TupleProjectionAccessor projAccessor
TupleData tupleData
TupleProjection outputProj
BTreeDescriptor treeDescriptor
SegmentAccessor scratchAccessor
BTreeOwnerRootMap * pRootMap
SharedBTreeAccessBase pBTreeAccessBase
SharedBTreeReader pBTreeReader
DynamicParamId rootPageIdParamId
SharedExecStreamBufAccessor pOutAccessor
bool isOpen
 Whether this stream is currently open.
ExecStreamGraph * pGraph
 Dataflow graph containing this stream.
ExecStreamId id
 Identifier for this stream; local to its containing graph.
std::string name
 Name of stream, as known by optimizer.
SharedDynamicParamManager pDynamicParamManager
 The dynamic parameter manager available to this stream.
SharedLogicalTxn pTxn
 The transaction embracing the stream.
ExecStreamResourceQuantity resourceAllocation
 Resource quantities currently allocated to this stream.
SharedCacheAccessor pQuotaAccessor
 CacheAccessor used for quota tracking.
SharedCacheAccessor pScratchQuotaAccessor
 CacheAccessor used for scratch page quota tracking.
bool needsClose
SharedExecStreamBufAccessor pInAccessor

Private Types

enum  DirectiveOrdinal { LOWER_BOUND_DIRECTIVE = 0, UPPER_BOUND_DIRECTIVE = 1 }
 Ordinals of lower/upper bounds within directive tuple. More...

Detailed Description

BTreeSearchExecStream reads keys from a child and returns matching tuples in the BTree.

Optionally, values from the input may also be joined to the output (in which case they come before the values read from the BTree).

Author:
John V. Sichi
Version:
Id
//open/dev/fennel/ftrs/BTreeSearchExecStream.h#14

Definition at line 105 of file BTreeSearchExecStream.h.

Member Enumeration Documentation

enum BTreeSearchExecStream::DirectiveOrdinal [private]

Ordinals of lower/upper bounds within directive tuple.

Enumerator:
LOWER_BOUND_DIRECTIVE 
UPPER_BOUND_DIRECTIVE 

Definition at line 111 of file BTreeSearchExecStream.h.

00111                           {
00112         LOWER_BOUND_DIRECTIVE = 0,
00113         UPPER_BOUND_DIRECTIVE = 1
00114     };

Member Function Documentation

bool BTreeSearchExecStream::innerSearchLoop (  )  [protected]

Reimplemented in BTreePrefetchSearchExecStream.

Definition at line 198 of file BTreeSearchExecStream.cpp.

References inputKeyData, SingleInputExecStream::pInAccessor, BTreeReadExecStream::pReader, pSearchKey, readDirectives(), readSearchKey(), readUpperBoundKey(), and searchForKey().

Referenced by BTreeSearchUniqueExecStream::execute(), and execute().

00199 {
00200     while (!pReader->isPositioned()) {
00201         if (!pInAccessor->demandData()) {
00202             return false;
00203         }
00204 
00205         readSearchKey();
00206         readDirectives();
00207         pSearchKey = &inputKeyData;
00208         readUpperBoundKey();
00209         if (!searchForKey()) {
00210             pInAccessor->consumeTuple();
00211         }
00212     }
00213     return true;
00214 }

ExecStreamResult BTreeSearchExecStream::innerFetchLoop ( ExecStreamQuantum const &  quantum,
uint &  nTuples 
) [protected]

Definition at line 446 of file BTreeSearchExecStream.cpp.

References EXECRC_BUF_OVERFLOW, EXECRC_QUANTUM_EXPIRED, EXECRC_YIELD, nJoinAttributes, ExecStreamQuantum::nTuplesMax, SingleOutputExecStream::pOutAccessor, BTreeReadExecStream::pReader, BTreeReadExecStream::projAccessor, reachedTupleLimit(), testInterval(), BTreeReadExecStream::tupleData, and TupleProjectionAccessor::unmarshal().

Referenced by execute(), and BTreePrefetchSearchExecStream::execute().

00449 {
00450     for (;;) {
00451         if (nTuples >= quantum.nTuplesMax) {
00452             return EXECRC_QUANTUM_EXPIRED;
00453         }
00454         if (reachedTupleLimit(nTuples)) {
00455             return EXECRC_BUF_OVERFLOW;
00456         }
00457         if (pOutAccessor->produceTuple(tupleData)) {
00458             ++nTuples;
00459         } else {
00460             return EXECRC_BUF_OVERFLOW;
00461         }
00462         if (pReader->searchNext()) {
00463             if (testInterval()) {
00464                 projAccessor.unmarshal(
00465                     tupleData.begin() + nJoinAttributes);
00466                 // continue with inner fetch loop
00467                 continue;
00468             }
00469         }
00470         pReader->endSearch();
00471         // break out of this loop to enable a new key search
00472         return EXECRC_YIELD;
00473     }
00474 }

void BTreeSearchExecStream::readDirectives (  )  [protected]

Definition at line 265 of file BTreeSearchExecStream.cpp.

References directiveAccessor, directiveData, LOWER_BOUND_DIRECTIVE, lowerBoundDirective, SEARCH_CLOSED_LOWER, SEARCH_CLOSED_UPPER, TupleProjectionAccessor::size(), TupleProjectionAccessor::unmarshal(), UPPER_BOUND_DIRECTIVE, and upperBoundDirective.

Referenced by BTreePrefetchSearchExecStream::getPrefetchSearchKey(), and innerSearchLoop().

00266 {
00267     if (!directiveAccessor.size()) {
00268         // default to point intervals
00269         lowerBoundDirective = SEARCH_CLOSED_LOWER;
00270         upperBoundDirective = SEARCH_CLOSED_UPPER;
00271         return;
00272     }
00273 
00274     directiveAccessor.unmarshal(directiveData);
00275 
00276     // directives can never be null
00277     assert(directiveData[LOWER_BOUND_DIRECTIVE].pData);
00278     assert(directiveData[UPPER_BOUND_DIRECTIVE].pData);
00279 
00280     lowerBoundDirective =
00281         SearchEndpoint(*(directiveData[LOWER_BOUND_DIRECTIVE].pData));
00282     upperBoundDirective =
00283         SearchEndpoint(*(directiveData[UPPER_BOUND_DIRECTIVE].pData));
00284 }

bool BTreeSearchExecStream::testInterval (  )  [protected]

Definition at line 390 of file BTreeSearchExecStream.cpp.

References checkNextKey(), TupleDescriptor::compareTuples(), TupleDescriptor::compareTuplesKey(), inputKeyDesc, leastUpper, lowerBoundDirective, pSearchKey, readerKeyAccessor, readerKeyData, SEARCH_CLOSED_LOWER, SEARCH_CLOSED_UPPER, SEARCH_UNBOUNDED_UPPER, TupleProjectionAccessor::unmarshal(), upperBoundData, and upperBoundDirective.

Referenced by innerFetchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), and searchForKey().

00391 {
00392     if (upperBoundDirective == SEARCH_UNBOUNDED_UPPER) {
00393         // if more than one search key in an unbounded search, the first part
00394         // of the key must be equality, so make sure that part of the key
00395         // matches
00396         if (pSearchKey->size() > 1) {
00397             readerKeyAccessor.unmarshal(readerKeyData);
00398             int c =
00399                 inputKeyDesc.compareTuplesKey(
00400                     readerKeyData,
00401                     *pSearchKey,
00402                     pSearchKey->size() - 1);
00403             if (c != 0) {
00404                 return false;
00405             }
00406         }
00407         return true;
00408     } else {
00409         readerKeyAccessor.unmarshal(readerKeyData);
00410         int c = inputKeyDesc.compareTuples(upperBoundData, readerKeyData);
00411         if (upperBoundDirective == SEARCH_CLOSED_UPPER) {
00412             // if this is a greatest lower bound equality search on > 1 key,
00413             // it is possible that we are positioned one key to the left of
00414             // our desired key position; move forward one key to see if there
00415             // is a match
00416             if (!leastUpper && lowerBoundDirective == SEARCH_CLOSED_LOWER &&
00417                 pSearchKey->size() > 1 && c > 0)
00418             {
00419                 return checkNextKey();
00420             }
00421             if (c >= 0) {
00422                 return true;
00423             }
00424         } else {
00425             if (c > 0) {
00426                 return true;
00427             }
00428         }
00429     }
00430     return false;
00431 }

void BTreeSearchExecStream::readSearchKey (  )  [protected]

Reads the search key either from the input stream or dynamic parameters.

Definition at line 216 of file BTreeSearchExecStream.cpp.

References dynamicKeysRead, inputKeyAccessor, inputKeyData, ExecStream::pDynamicParamManager, SingleInputExecStream::pInAccessor, searchKeyParams, searchKeyProj, TupleProjectionAccessor::size(), TupleAccessor::unmarshal(), and TupleProjectionAccessor::unmarshal().

Referenced by BTreePrefetchSearchExecStream::getPrefetchSearchKey(), and innerSearchLoop().

00217 {
00218     // Even if we're not going to be reading the key values from the input
00219     // stream, we'll later need to read the directives, so we need to access
00220     // the input stream tuple
00221     TupleAccessor &inputAccessor =
00222         pInAccessor->accessConsumptionTuple();
00223 
00224     if (searchKeyParams.size() == 0) {
00225         if (inputKeyAccessor.size()) {
00226             // unmarshal just the key projection
00227             inputKeyAccessor.unmarshal(inputKeyData);
00228         } else {
00229             // umarshal the whole thing as the key
00230             inputAccessor.unmarshal(inputKeyData);
00231         }
00232     } else {
00233         // When passing in key values through dynamic parameters, only one
00234         // search range is allowed
00235         assert(!dynamicKeysRead);
00236 
00237         // NOTE zfong 5/22/07 - We are accessing the dynamic parameter values
00238         // by reference rather than value.  Therefore, the underlying values
00239         // are expected to be fixed for the duration of this search.  Likewise,
00240         // in readUpperBoundKey().
00241         uint nParams = searchKeyParams.size();
00242         searchKeyProj.clear();
00243         for (uint i = 0; i < nParams / 2; i++) {
00244             inputKeyData[searchKeyParams[i].keyOffset] =
00245                 pDynamicParamManager->getParam(
00246                     searchKeyParams[i].dynamicParamId).getDatum();
00247             searchKeyProj.push_back(i);
00248         }
00249         // If there are an odd number of parameters, determine whether the
00250         // next parameter corresponds to the lower or upper bound
00251         if ((nParams%2) && searchKeyParams[nParams/2].keyOffset == nParams/2) {
00252             inputKeyData[nParams / 2] =
00253                 pDynamicParamManager->getParam(
00254                     searchKeyParams[nParams / 2].dynamicParamId).getDatum();
00255             // The search key projection in the case of dynamic parameters
00256             // consists of only the portion of the search key that corresponds
00257             // to actual parameters supplied
00258             searchKeyProj.push_back(nParams / 2);
00259         }
00260 
00261         dynamicKeysRead = true;
00262     }
00263 }

void BTreeSearchExecStream::readUpperBoundKey (  )  [protected]

Reads the upper bound key either from the input stream or dynamic parameters.

Definition at line 352 of file BTreeSearchExecStream.cpp.

References ExecStream::pDynamicParamManager, pSearchKey, searchKeyParams, TupleProjectionAccessor::unmarshal(), upperBoundAccessor, upperBoundData, upperBoundDesc, and upperBoundKeyProj.

Referenced by BTreePrefetchSearchExecStream::getPrefetchSearchKey(), and innerSearchLoop().

00353 {
00354     if (searchKeyParams.size() == 0) {
00355         if (upperBoundDesc.size()) {
00356             upperBoundAccessor.unmarshal(upperBoundData);
00357         } else {
00358             upperBoundData = *pSearchKey;
00359         }
00360     } else {
00361         // If there are an odd number of parameters, determine whether the
00362         // first parameter in the second group of parameters corresponds
00363         // to the lower or upper bound.  If there are an even number of
00364         // parameters, always read that first parameter.
00365         uint nParams = searchKeyParams.size();
00366         // The search key projection in the case of dynamic parameters
00367         // consists of only the portion of the search key that corresponds
00368         // to actual parameters supplied.  Since the lower and upper bound
00369         // keys may have a different number of supplied parameters, we need
00370         // to recreate the projection.
00371         upperBoundKeyProj.clear();
00372         if (!(nParams % 2)
00373             || searchKeyParams[nParams / 2].keyOffset == nParams / 2 + 1)
00374         {
00375             upperBoundData[0] =
00376                 pDynamicParamManager->getParam(
00377                     searchKeyParams[nParams / 2].dynamicParamId).getDatum();
00378             upperBoundKeyProj.push_back(0);
00379         }
00380         uint keySize = upperBoundData.size();
00381         for (uint i = nParams / 2 + 1; i < nParams; i++) {
00382             upperBoundData[searchKeyParams[i].keyOffset - keySize] =
00383                 pDynamicParamManager->getParam(
00384                     searchKeyParams[i].dynamicParamId).getDatum();
00385             upperBoundKeyProj.push_back(i - keySize);
00386         }
00387     }
00388 }

bool BTreeSearchExecStream::checkNextKey (  )  [protected]

Determines if the next key value is within the upper bound search range.

Returns:
true if next key value is within upper bound search range

Definition at line 433 of file BTreeSearchExecStream.cpp.

References TupleDescriptor::compareTuples(), inputKeyDesc, BTreeReadExecStream::pReader, readerKeyAccessor, readerKeyData, TupleProjectionAccessor::unmarshal(), and upperBoundData.

Referenced by testInterval().

00434 {
00435     // read the next key
00436     if (!pReader->searchNext()) {
00437         return false;
00438     }
00439     readerKeyAccessor.unmarshal(readerKeyData);
00440     int c = inputKeyDesc.compareTuples(upperBoundData, readerKeyData);
00441     // should only have to read one more key
00442     assert(c <= 0);
00443     return (c == 0);
00444 }

bool BTreeSearchExecStream::reachedTupleLimit ( uint  nTuples  )  [protected, virtual]

Determines if enough tuples have been produced for this stream.

Parameters:
nTuples number of tuples produced thus far
Returns:
true if tuple limit reached

Reimplemented in LbmSearchExecStream.

Definition at line 482 of file BTreeSearchExecStream.cpp.

Referenced by innerFetchLoop().

00483 {
00484     return false;
00485 }

bool BTreeSearchExecStream::searchForKey (  )  [protected]

Searches the btree for a specific key.

Returns:
true if the search yielded matching keys

Definition at line 286 of file BTreeSearchExecStream.cpp.

References TupleData::containsNull(), DUP_SEEK_BEGIN, DUP_SEEK_END, inputJoinAccessor, leastUpper, lowerBoundDirective, nJoinAttributes, outerJoin, BTreeReadExecStream::pReader, preFilterNulls, BTreeReadExecStream::projAccessor, pSearchKey, SEARCH_CLOSED_LOWER, SEARCH_OPEN_LOWER, SEARCH_UNBOUNDED_LOWER, searchKeyProj, TupleProjectionAccessor::size(), testInterval(), BTreeReadExecStream::tupleData, TupleProjectionAccessor::unmarshal(), upperBoundData, and upperBoundKeyProj.

Referenced by innerSearchLoop(), and BTreePrefetchSearchExecStream::innerSearchLoop().

00287 {
00288     switch (lowerBoundDirective) {
00289     case SEARCH_UNBOUNDED_LOWER:
00290         if (pSearchKey->size() <= 1) {
00291             pReader->searchFirst();
00292             break;
00293         }
00294         // otherwise, this is the case where we have > 1 key and a
00295         // non-equality search on the last key; in this case, we need
00296         // to position to the equality portion of the key
00297     case SEARCH_CLOSED_LOWER:
00298         pReader->searchForKey(*pSearchKey, DUP_SEEK_BEGIN, leastUpper);
00299         break;
00300     case SEARCH_OPEN_LOWER:
00301         pReader->searchForKey(*pSearchKey, DUP_SEEK_END, leastUpper);
00302         break;
00303     default:
00304         permFail(
00305             "unexpected lower bound directive:  "
00306             << (char) lowerBoundDirective);
00307     }
00308 
00309     bool match = true;
00310     if (preFilterNulls && pSearchKey->containsNull(searchKeyProj)) {
00311         // null never matches when preFilterNulls is true;
00312         // TODO:  so don't bother searching, but need a way
00313         // to fake pReader->isPositioned()
00314         match = false;
00315     } else {
00316         if (pReader->isSingular()) {
00317             // Searched past end of tree.
00318             match = false;
00319         } else {
00320             if (preFilterNulls &&
00321                 upperBoundData.containsNull(upperBoundKeyProj))
00322             {
00323                 match = false;
00324             } else {
00325                 match = testInterval();
00326             }
00327         }
00328     }
00329 
00330     if (!match) {
00331         if (!outerJoin) {
00332             pReader->endSearch();
00333             return false;
00334         }
00335         // no match, so make up null values for the missing attributes
00336         for (uint i = nJoinAttributes; i < tupleData.size(); ++i) {
00337             tupleData[i].pData = NULL;
00338         }
00339     } else {
00340         projAccessor.unmarshal(
00341             tupleData.begin() + nJoinAttributes);
00342     }
00343 
00344     // propagate join attributes
00345     if (inputJoinAccessor.size()) {
00346         inputJoinAccessor.unmarshal(tupleData);
00347     }
00348 
00349     return true;
00350 }

void BTreeSearchExecStream::prepare ( BTreeSearchExecStreamParams const &  params  ) 

Reimplemented in BTreeSearchUniqueExecStream.

Definition at line 32 of file BTreeSearchExecStream.cpp.

References TupleProjectionAccessor::bind(), TupleData::compute(), TupleDescriptor::containsNullable(), directiveAccessor, directiveData, BTreeSearchExecStreamParams::inputDirectiveProj, inputJoinAccessor, BTreeSearchExecStreamParams::inputJoinProj, inputKeyAccessor, inputKeyData, inputKeyDesc, BTreeSearchExecStreamParams::inputKeyProj, BTreeDescriptor::keyProjection, leastUpper, LOWER_BOUND_DIRECTIVE, StandardTypeDescriptorFactory::newDataType(), nJoinAttributes, BTreeSearchExecStreamParams::outerJoin, outerJoin, BTreeReadExecStreamParams::outputProj, SingleOutputExecStreamParams::outputTupleDesc, SingleInputExecStream::pInAccessor, preFilterNulls, ConduitExecStream::prepare(), BTreeReadExecStream::prepare(), TupleDescriptor::projectFrom(), readerKeyData, BTreeSearchExecStreamParams::searchKeyParams, searchKeyParams, searchKeyProj, STANDARD_TYPE_CHAR, BTreeExecStream::treeDescriptor, UPPER_BOUND_DIRECTIVE, upperBoundAccessor, upperBoundData, upperBoundDesc, and upperBoundKeyProj.

Referenced by BTreeSearchUniqueExecStream::prepare(), and BTreePrefetchSearchExecStream::prepare().

00033 {
00034     BTreeReadExecStream::prepare(params);
00035     ConduitExecStream::prepare(params);
00036 
00037     leastUpper = true;
00038     outerJoin = params.outerJoin;
00039     searchKeyParams = params.searchKeyParams;
00040 
00041     // TODO:  assert inputDesc is a prefix of BTree key
00042 
00043     TupleDescriptor const &inputDesc = pInAccessor->getTupleDesc();
00044 
00045     TupleAccessor &inputAccessor = pInAccessor->getConsumptionTupleAccessor();
00046 
00047     if (params.inputDirectiveProj.size()) {
00048         assert(params.inputDirectiveProj.size() == 2);
00049         // If a directive is present, we must be projecting the keys, otherwise
00050         // the directives and keys would be overlapping, which doesn't make
00051         // sense.  Also, there should be an even number of keys, because
00052         // lower and upper bounds come together in the same tuple.
00053         assert(params.inputKeyProj.size() > 0);
00054         assert((params.inputKeyProj.size() % 2) == 0);
00055         directiveAccessor.bind(inputAccessor, params.inputDirectiveProj);
00056         TupleDescriptor inputDirectiveDesc;
00057         inputDirectiveDesc.projectFrom(inputDesc, params.inputDirectiveProj);
00058 
00059         // verify that the directive attribute has the correct datatype
00060         StandardTypeDescriptorFactory stdTypeFactory;
00061         TupleAttributeDescriptor expectedDirectiveDesc(
00062             stdTypeFactory.newDataType(STANDARD_TYPE_CHAR));
00063         expectedDirectiveDesc.cbStorage = 1;
00064         assert(
00065             inputDirectiveDesc[LOWER_BOUND_DIRECTIVE] == expectedDirectiveDesc);
00066         assert(
00067             inputDirectiveDesc[UPPER_BOUND_DIRECTIVE] == expectedDirectiveDesc);
00068 
00069         directiveData.compute(inputDirectiveDesc);
00070     }
00071 
00072     if (params.inputKeyProj.size()) {
00073         TupleProjection inputKeyProj = params.inputKeyProj;
00074         if (params.inputDirectiveProj.size()) {
00075             // The inputKeyProj gives us both lower and upper bounds;
00076             // split them because we will access them separately.
00077             TupleProjection upperBoundProj;
00078             int n = inputKeyProj.size() / 2;
00079             // This resize extends...
00080             upperBoundProj.resize(n);
00081             // ...so we have space to copy...
00082             std::copy(
00083                 inputKeyProj.begin() + n,
00084                 inputKeyProj.end(),
00085                 upperBoundProj.begin());
00086             // ...whereas this one truncates what was copied.
00087             inputKeyProj.resize(n);
00088 
00089             upperBoundAccessor.bind(inputAccessor, upperBoundProj);
00090             upperBoundDesc.projectFrom(inputDesc, upperBoundProj);
00091             upperBoundData.compute(upperBoundDesc);
00092 
00093             assert(
00094                 searchKeyParams.size() == 0 ||
00095                 (searchKeyParams.size() >= (n-1)*2+1 &&
00096                     searchKeyParams.size() <= n*2));
00097         } else {
00098             assert(searchKeyParams.size() == 0);
00099         }
00100         inputKeyAccessor.bind(inputAccessor,inputKeyProj);
00101         inputKeyDesc.projectFrom(inputDesc,inputKeyProj);
00102     } else {
00103         inputKeyDesc = inputDesc;
00104         assert(searchKeyParams.size() == 0);
00105     }
00106     inputKeyData.compute(inputKeyDesc);
00107 
00108     if (upperBoundDesc.size()) {
00109         // Verify that all the splitting above came out with the same
00110         // key type for both lower and upper bounds.
00111         assert(upperBoundDesc == inputKeyDesc);
00112     }
00113 
00114     preFilterNulls = false;
00115     if ((outerJoin && inputKeyDesc.containsNullable()) ||
00116         searchKeyParams.size() > 0)
00117     {
00118         // When we're doing an outer join or a lookup via dynamic parameters,
00119         // the input keys have not had nulls eliminated yet, so we have to
00120         // treat those cases specially.
00121         preFilterNulls = true;
00122 
00123         // Setup a projection of the search key.  In the case of a dynamic
00124         // parameter search, this will be done later when we read the
00125         // parameters
00126         if (searchKeyParams.size() == 0) {
00127             for (uint i = 0; i < inputKeyData.size(); i++) {
00128                 searchKeyProj.push_back(i);
00129                 upperBoundKeyProj.push_back(i);
00130             }
00131         }
00132     }
00133 
00134     inputJoinAccessor.bind(inputAccessor,params.inputJoinProj);
00135 
00136     TupleDescriptor joinDescriptor;
00137     joinDescriptor.projectFrom(inputDesc,params.inputJoinProj);
00138 
00139     TupleProjection readerKeyProj = treeDescriptor.keyProjection;
00140     readerKeyProj.resize(inputKeyDesc.size());
00141     readerKeyData.compute(inputKeyDesc);
00142 
00143     nJoinAttributes = params.outputTupleDesc.size() - params.outputProj.size();
00144 }

void BTreeSearchExecStream::open ( bool  restart  )  [virtual]

Opens this stream, acquiring any resources needed in order to be able to fetch data.

A precondition is that input streams must already be opened. A stream can be closed and reopened.

Parameters:
restart if true, the stream must be already open, and should reset itself to start from the beginning of its result set

Reimplemented from ConduitExecStream.

Reimplemented in BTreePrefetchSearchExecStream.

Definition at line 146 of file BTreeSearchExecStream.cpp.

References TupleProjectionAccessor::bind(), dynamicKeysRead, inputKeyDesc, BTreeDescriptor::keyProjection, opaqueToInt(), ConduitExecStream::open(), BTreeReadExecStream::open(), ExecStream::pDynamicParamManager, BTreeReadExecStream::pReader, readerKeyAccessor, BTreeDescriptor::rootPageId, BTreeExecStream::rootPageIdParamId, and BTreeExecStream::treeDescriptor.

Referenced by BTreePrefetchSearchExecStream::open().

00147 {
00148     // Read the parameter value of the btree's root page before
00149     // initializing a btree reader
00150     if (!restart && opaqueToInt(rootPageIdParamId) > 0) {
00151         treeDescriptor.rootPageId =
00152             *reinterpret_cast<PageId const *>(
00153             pDynamicParamManager->getParam(rootPageIdParamId).getDatum().pData);
00154     }
00155     BTreeReadExecStream::open(restart);
00156     ConduitExecStream::open(restart);
00157     dynamicKeysRead = false;
00158 
00159     if (restart) {
00160         return;
00161     }
00162 
00163     // Bind the accessor now that we've initialized the btree reader
00164     TupleProjection readerKeyProj = treeDescriptor.keyProjection;
00165     readerKeyProj.resize(inputKeyDesc.size());
00166     readerKeyAccessor.bind(
00167         pReader->getTupleAccessorForRead(),
00168         readerKeyProj);
00169 }

ExecStreamResult BTreeSearchExecStream::execute ( ExecStreamQuantum const &  quantum  )  [virtual]

Executes this stream.

Parameters:
quantum governs the maximum amount of execution to perform
Returns:
code indicating reason execution ceased

Implements ExecStream.

Reimplemented in BTreePrefetchSearchExecStream, and BTreeSearchUniqueExecStream.

Definition at line 171 of file BTreeSearchExecStream.cpp.

References EXECRC_BUF_UNDERFLOW, EXECRC_YIELD, innerFetchLoop(), innerSearchLoop(), ExecStreamQuantum::nTuplesMax, SingleInputExecStream::pInAccessor, and ConduitExecStream::precheckConduitBuffers().

00173 {
00174     ExecStreamResult rc = precheckConduitBuffers();
00175     if (rc != EXECRC_YIELD) {
00176         return rc;
00177     }
00178 
00179     uint nTuples = 0;
00180     assert(quantum.nTuplesMax > 0);
00181 
00182     // outer loop
00183     for (;;) {
00184         if (!innerSearchLoop()) {
00185             return EXECRC_BUF_UNDERFLOW;
00186         }
00187 
00188         // inner fetch loop
00189         rc = innerFetchLoop(quantum, nTuples);
00190         if (rc == EXECRC_YIELD) {
00191             pInAccessor->consumeTuple();
00192         } else {
00193             return rc;
00194         }
00195     }
00196 }

void BTreeSearchExecStream::closeImpl (  )  [virtual]

Implements ClosableObject.

ExecStream implementations may override this to release any resources acquired while open.

Reimplemented from BTreeReadExecStream.

Reimplemented in BTreePrefetchSearchExecStream.

Definition at line 476 of file BTreeSearchExecStream.cpp.

References BTreeReadExecStream::closeImpl(), and ExecStream::closeImpl().

Referenced by BTreePrefetchSearchExecStream::closeImpl().

00477 {
00478     ConduitExecStream::closeImpl();
00479     BTreeReadExecStream::closeImpl();
00480 }

void BTreeReadExecStream::prepare ( BTreeReadExecStreamParams const &  params  )  [virtual, inherited]

Definition at line 31 of file BTreeReadExecStream.cpp.

References TupleData::compute(), BTreeReadExecStreamParams::outputProj, BTreeReadExecStream::outputProj, SingleOutputExecStreamParams::outputTupleDesc, BTreeExecStream::prepare(), and BTreeReadExecStream::tupleData.

Referenced by prepare(), and BTreeScanExecStream::prepare().

00032 {
00033     BTreeExecStream::prepare(params);
00034     outputProj.assign(params.outputProj.begin(), params.outputProj.end());
00035     tupleData.compute(params.outputTupleDesc);
00036 }

void BTreeExecStream::prepare ( BTreeExecStreamParams const &  params  )  [virtual, inherited]

Definition at line 30 of file BTreeExecStream.cpp.

References BTreeExecStream::copyParamsToDescriptor(), ExecStreamParams::pCacheAccessor, SingleOutputExecStream::prepare(), BTreeParams::pRootMap, BTreeExecStream::pRootMap, BTreeParams::rootPageIdParamId, BTreeExecStream::rootPageIdParamId, ExecStreamParams::scratchAccessor, BTreeExecStream::scratchAccessor, and BTreeExecStream::treeDescriptor.

Referenced by LcsClusterAppendExecStream::prepare(), LbmGeneratorExecStream::prepare(), BTreeReadExecStream::prepare(), and BTreeInsertExecStream::prepare().

00031 {
00032     SingleOutputExecStream::prepare(params);
00033 
00034     copyParamsToDescriptor(treeDescriptor,params,params.pCacheAccessor);
00035     scratchAccessor = params.scratchAccessor;
00036     pRootMap = params.pRootMap;
00037     rootPageIdParamId = params.rootPageIdParamId;
00038 }

void SingleOutputExecStream::prepare ( SingleOutputExecStreamParams const &  params  )  [virtual, inherited]

Definition at line 48 of file SingleOutputExecStream.cpp.

References SingleOutputExecStream::getOutputBufProvision(), SingleOutputExecStreamParams::outputTupleDesc, SingleOutputExecStreamParams::outputTupleFormat, SingleOutputExecStream::pOutAccessor, and ExecStream::prepare().

Referenced by BTreeExecStream::prepare(), FlatFileExecStreamImpl::prepare(), ValuesExecStream::prepare(), MockResourceExecStream::prepare(), MockProducerExecStream::prepare(), ConfluenceExecStream::prepare(), and ConduitExecStream::prepare().

00049 {
00050     ExecStream::prepare(params);
00051     assert(pOutAccessor);
00052     assert(pOutAccessor->getProvision() == getOutputBufProvision());
00053     if (pOutAccessor->getTupleDesc().empty()) {
00054         assert(!params.outputTupleDesc.empty());
00055         pOutAccessor->setTupleShape(
00056             params.outputTupleDesc,
00057             params.outputTupleFormat);
00058     }
00059 }

void ExecStream::prepare ( ExecStreamParams const &  params  )  [virtual, inherited]

Prepares this stream for execution.

A precondition is that input streams must already be defined and prepared. As an effect of this call, the tuple shape should be defined for all output buffers and remain unchanged for the lifetime of the stream. This method is only ever called once, before the first open. Although this method is virtual, derived classes may choose to define an overloaded version instead with a specialized covariant parameter class.

Parameters:
params instance of stream parameterization class which should be used to prepare this stream

Definition at line 84 of file ExecStream.cpp.

References ExecStreamGraph::getDynamicParamManager(), SegmentAccessor::pCacheAccessor, ExecStreamParams::pCacheAccessor, ExecStream::pDynamicParamManager, ExecStream::pGraph, ExecStream::pQuotaAccessor, ExecStream::pScratchQuotaAccessor, and ExecStreamParams::scratchAccessor.

Referenced by JavaTransformExecStream::prepare(), SingleOutputExecStream::prepare(), and SingleInputExecStream::prepare().

00085 {
00086     if (pGraph) {
00087         pDynamicParamManager = pGraph->getDynamicParamManager();
00088     }
00089     pQuotaAccessor = params.pCacheAccessor;
00090     pScratchQuotaAccessor = params.scratchAccessor.pCacheAccessor;
00091 }

void BTreeReadExecStream::getResourceRequirements ( ExecStreamResourceQuantity &  minQuantity,
ExecStreamResourceQuantity &  optQuantity 
) [virtual, inherited]

Reimplemented from ExecStream.

Definition at line 38 of file BTreeReadExecStream.cpp.

References ExecStream::getResourceRequirements(), and ExecStreamResourceQuantity::nCachePages.

Referenced by BTreePrefetchSearchExecStream::getResourceRequirements().

00041 {
00042     BTreeExecStream::getResourceRequirements(minQuantity,optQuantity);
00043 
00044     // one page for BTreeReader
00045     minQuantity.nCachePages += 1;
00046 
00047     // TODO:  use opt to govern prefetch and come up with a good formula
00048     optQuantity = minQuantity;
00049 }

void ExecStream::getResourceRequirements ( ExecStreamResourceQuantity &  minQuantity,
ExecStreamResourceQuantity &  optQuantity,
ExecStreamResourceSettingType &  optType 
) [virtual, inherited]

Determines resource requirements for this stream.

Default implementation declares zero resource requirements.

Parameters:
minQuantity receives the minimum resource quantity needed by this stream in order to execute
optQuantity receives the resource quantity needed by this stream in order to execute optimally
optType Receives the value indicating the accuracy of the optQuantity parameter. This parameter is optional and defaults to EXEC_RESOURCE_ACCURATE if omitted. If the optimum setting is an estimate or no value can be specified (e.g., due to lack of statistics), then this parameter needs to be used to indicate a non-accurate optimum resource setting.

Reimplemented in MockResourceExecStream, BTreePrefetchSearchExecStream, LhxAggExecStream, LhxJoinExecStream, LbmGeneratorExecStream, LbmUnionExecStream, and ExternalSortExecStreamImpl.

Definition at line 93 of file ExecStream.cpp.

References EXEC_RESOURCE_ACCURATE.

Referenced by ExternalSortExecStreamImpl::getResourceRequirements(), LcsRowScanBaseExecStream::getResourceRequirements(), LcsClusterAppendExecStream::getResourceRequirements(), LbmUnionExecStream::getResourceRequirements(), LbmSplicerExecStream::getResourceRequirements(), LbmGeneratorExecStream::getResourceRequirements(), LbmChopperExecStream::getResourceRequirements(), LhxJoinExecStream::getResourceRequirements(), LhxAggExecStream::getResourceRequirements(), FtrsTableWriterExecStream::getResourceRequirements(), BTreeReadExecStream::getResourceRequirements(), BTreeInsertExecStream::getResourceRequirements(), FlatFileExecStreamImpl::getResourceRequirements(), SegBufferWriterExecStream::getResourceRequirements(), SegBufferReaderExecStream::getResourceRequirements(), SegBufferExecStream::getResourceRequirements(), ScratchBufferExecStream::getResourceRequirements(), and DoubleBufferExecStream::getResourceRequirements().

00097 {
00098     getResourceRequirements(minQuantity, optQuantity);
00099     optType = EXEC_RESOURCE_ACCURATE;
00100 }

SharedBTreeReader BTreeExecStream::newReader (  )  [protected, virtual, inherited]

Reimplemented in BTreePrefetchSearchExecStream.

Definition at line 67 of file BTreeExecStream.cpp.

References BTreeExecStream::pBTreeAccessBase, BTreeExecStream::pBTreeReader, and BTreeExecStream::treeDescriptor.

Referenced by BTreeReadExecStream::open().

00068 {
00069     SharedBTreeReader pReader = SharedBTreeReader(
00070         new BTreeReader(treeDescriptor));
00071     pBTreeAccessBase = pBTreeReader = pReader;
00072     return pReader;
00073 }

SharedBTreeWriter BTreeExecStream::newWriter ( bool  monotonic = false  )  [protected, inherited]

Definition at line 75 of file BTreeExecStream.cpp.

References BTreeExecStream::pBTreeAccessBase, BTreeExecStream::pBTreeReader, BTreeExecStream::scratchAccessor, and BTreeExecStream::treeDescriptor.

Referenced by FtrsTableWriter::createIndexWriter(), and BTreeInsertExecStream::open().

00076 {
00077     SharedBTreeWriter pWriter = SharedBTreeWriter(
00078         new BTreeWriter(treeDescriptor,scratchAccessor,monotonic));
00079     pBTreeAccessBase = pBTreeReader = pWriter;
00080     return pWriter;
00081 }

SharedBTreeWriter BTreeExecStream::newWriter ( BTreeExecStreamParams const &  params  )  [static, inherited]

Definition at line 83 of file BTreeExecStream.cpp.

References BTreeExecStream::copyParamsToDescriptor(), ExecStreamParams::pCacheAccessor, ExecStreamParams::scratchAccessor, and BTreeExecStream::treeDescriptor.

00085 {
00086     BTreeDescriptor treeDescriptor;
00087     copyParamsToDescriptor(treeDescriptor,params,params.pCacheAccessor);
00088     return SharedBTreeWriter(
00089         new BTreeWriter(
00090             treeDescriptor,params.scratchAccessor));
00091 }

void BTreeExecStream::endSearch (  )  [protected, virtual, inherited]

Forgets the current reader or writer's search, releasing any page locks.

Definition at line 107 of file BTreeExecStream.cpp.

References BTreeExecStream::pBTreeReader.

Referenced by BTreeExecStream::closeImpl(), and BTreeExecStream::open().

00108 {
00109     if (pBTreeReader && pBTreeReader->isSingular() == false) {
00110         pBTreeReader->endSearch();
00111     }
00112 }

void BTreeExecStream::copyParamsToDescriptor ( BTreeDescriptor &  ,
BTreeParams const &  ,
SharedCacheAccessor const &   
) [static, inherited]

Definition at line 93 of file BTreeExecStream.cpp.

References BTreeParams::keyProj, BTreeDescriptor::keyProjection, BTreeParams::pageOwnerId, BTreeDescriptor::pageOwnerId, SegmentAccessor::pCacheAccessor, BTreeParams::pSegment, SegmentAccessor::pSegment, BTreeParams::rootPageId, BTreeDescriptor::rootPageId, BTreeDescriptor::segmentAccessor, BTreeParams::segmentId, BTreeDescriptor::segmentId, BTreeExecStream::treeDescriptor, BTreeParams::tupleDesc, and BTreeDescriptor::tupleDescriptor.

Referenced by BTreeExecStream::newWriter(), LbmSplicerExecStream::prepare(), and BTreeExecStream::prepare().

00097 {
00098     treeDescriptor.segmentAccessor.pSegment = params.pSegment;
00099     treeDescriptor.segmentAccessor.pCacheAccessor = pCacheAccessor;
00100     treeDescriptor.tupleDescriptor = params.tupleDesc;
00101     treeDescriptor.keyProjection = params.keyProj;
00102     treeDescriptor.rootPageId = params.rootPageId;
00103     treeDescriptor.segmentId = params.segmentId;
00104     treeDescriptor.pageOwnerId = params.pageOwnerId;
00105 }

void SingleOutputExecStream::setInputBufAccessors ( std::vector< SharedExecStreamBufAccessor > const &  inAccessors  )  [virtual, inherited]

Initializes the buffer accessors for inputs to this stream.

This method is only ever called once, before prepare.

Parameters:
inAccessors buffer accessors ordered by input stream

Implements ExecStream.

Reimplemented in ConduitExecStream, and ConfluenceExecStream.

Definition at line 35 of file SingleOutputExecStream.cpp.

00037 {
00038     assert(inAccessors.size() == 0);
00039 }

void SingleOutputExecStream::setOutputBufAccessors ( std::vector< SharedExecStreamBufAccessor > const &  outAccessors  )  [virtual, inherited]

Initializes the buffer accessors for outputs from this stream.

This method is only ever called once, before prepare.

Parameters:
outAccessors buffer accessors ordered by output stream

Implements ExecStream.

Reimplemented in ConduitExecStream.

Definition at line 41 of file SingleOutputExecStream.cpp.

References SingleOutputExecStream::pOutAccessor.

Referenced by ConduitExecStream::setOutputBufAccessors().

00043 {
00044     assert(outAccessors.size() == 1);
00045     pOutAccessor = outAccessors[0];
00046 }

ExecStreamBufProvision SingleOutputExecStream::getOutputBufProvision (  )  const [virtual, inherited]

Queries the BufferProvision which this stream is capable of when producing tuples.

Returns:
supported model; default is BUFPROV_NONE

Reimplemented from ExecStream.

Reimplemented in BarrierExecStream, DoubleBufferExecStream, MergeExecStream, MockResourceExecStream, ScratchBufferExecStream, SegBufferExecStream, SegBufferReaderExecStream, ValuesExecStream, FtrsTableWriterExecStream, and LcsClusterAppendExecStream.

Definition at line 69 of file SingleOutputExecStream.cpp.

References BUFPROV_CONSUMER.

Referenced by SingleOutputExecStream::prepare().

00070 {
00071     return BUFPROV_CONSUMER;
00072 }

bool ExecStream::canEarlyClose (  )  [virtual, inherited]

Returns:
true if the stream can be closed early

Reimplemented in SegBufferWriterExecStream.

Definition at line 49 of file ExecStream.cpp.

00050 {
00051     return true;
00052 }

ExecStreamGraph & ExecStream::getGraph (  )  const [inline, inherited]

Returns:
reference to containing graph

Definition at line 293 of file ExecStream.h.

References ExecStream::pGraph.

Referenced by ExternalSortExecStreamImpl::execute(), JavaSinkExecStream::execute(), SegBufferWriterExecStream::execute(), SegBufferExecStream::execute(), BarrierExecStream::execute(), Java_net_sf_farrago_fennel_FennelStorage_tupleStreamFetch(), Java_net_sf_farrago_fennel_FennelStorage_tupleStreamTransformFetch(), JavaSinkExecStream::stuffByteBuffer(), and ExecStreamScheduler::traceStreamBuffers().

00294 {
00295     assert(pGraph);
00296     return *pGraph;
00297 }

ExecStreamId ExecStream::getStreamId (  )  const [inline, inherited]

Returns:
the identifier for this stream within containing graph

Definition at line 288 of file ExecStream.h.

References ExecStream::id.

Referenced by ExternalSortExecStreamImpl::execute(), SegBufferWriterExecStream::execute(), SegBufferExecStream::execute(), CorrelationJoinExecStream::execute(), BarrierExecStream::execute(), Java_net_sf_farrago_fennel_FennelStorage_tupleStreamTransformFetch(), JavaTransformExecStream::open(), SingleInputExecStream::open(), ConfluenceExecStream::open(), CartesianJoinExecStream::prepare(), ParallelExecStreamScheduler::readStream(), DfsTreeExecStreamScheduler::readStream(), LbmMinusExecStream::restartSubtrahends(), ExecStreamScheduler::tracePostExecution(), ExecStreamScheduler::tracePreExecution(), ExecStreamScheduler::traceStreamBuffers(), and ParallelExecStreamScheduler::tryExecuteTask().

00289 {
00290     return id;
00291 }

void ExecStream::setResourceAllocation ( ExecStreamResourceQuantity &  quantity  )  [virtual, inherited]

Sets current resource allocation for this stream.

If called while the stream is open, this indicates a request for the stream to dynamically adjust its memory usage. If the stream is incapable of honoring the request, it should update quantity with the actual amounts still in use.

Parameters:
quantity allocated resource quantity

Reimplemented in MockResourceExecStream, BTreePrefetchSearchExecStream, LhxAggExecStream, LhxJoinExecStream, LbmGeneratorExecStream, LbmUnionExecStream, and ExternalSortExecStreamImpl.

Definition at line 111 of file ExecStream.cpp.

References ExecStreamResourceQuantity::nCachePages, ExecStream::pQuotaAccessor, ExecStream::pScratchQuotaAccessor, and ExecStream::resourceAllocation.

Referenced by ExternalSortExecStreamImpl::setResourceAllocation(), LbmUnionExecStream::setResourceAllocation(), LbmGeneratorExecStream::setResourceAllocation(), LhxJoinExecStream::setResourceAllocation(), LhxAggExecStream::setResourceAllocation(), and BTreePrefetchSearchExecStream::setResourceAllocation().

00113 {
00114     resourceAllocation = quantity;
00115     if (pQuotaAccessor) {
00116         pQuotaAccessor->setMaxLockedPages(quantity.nCachePages);
00117     }
00118     if (pScratchQuotaAccessor) {
00119         pScratchQuotaAccessor->setMaxLockedPages(quantity.nCachePages);
00120     }
00121 }

void ExecStream::setName ( std::string const &   )  [virtual, inherited]

Sets unique name of this stream.

Definition at line 157 of file ExecStream.cpp.

References ExecStream::name.

00158 {
00159     name = nameInit;
00160 }

std::string const & ExecStream::getName (  )  const [virtual, inherited]

Returns:
the name of this stream, as known by the optimizer

Definition at line 162 of file ExecStream.cpp.

References ExecStream::name.

Referenced by DfsTreeExecStreamScheduler::findNextConsumer(), ParallelExecStreamScheduler::readStream(), DfsTreeExecStreamScheduler::readStream(), ExecStreamScheduler::tracePostExecution(), and ExecStreamScheduler::tracePreExecution().

00163 {
00164     return name;
00165 }

bool ExecStream::mayBlock (  )  const [virtual, inherited]

Queries whether this stream's implementation may block when execute() is called.

For accurate scheduling, non-blocking implementations are preferred; the scheduler must be aware of the potential for blocking so that it can allocate extra threads accordingly.

Returns:
whether stream may block; default is false

Definition at line 167 of file ExecStream.cpp.

00168 {
00169     return false;
00170 }

void ExecStream::checkAbort (  )  const [virtual, inherited]

Checks whether there is an abort request for this stream's scheduler.

Normally, streams don't need to check this, since the scheduler services abort requests in between quanta. However, streams which enter long-running loops need to check for themselves. If an abort is scheduled, this method will throw an AbortExcn automatically.

Definition at line 72 of file ExecStream.cpp.

References ExecStreamScheduler::checkAbort(), ExecStreamGraph::getScheduler(), and ExecStream::pGraph.

Referenced by LhxJoinExecStream::execute(), LhxAggExecStream::execute(), ExternalSortRunAccessor::fetch(), and ExternalSortMerger::fetch().

00073 {
00074     if (!pGraph) {
00075         return;
00076     }
00077     ExecStreamScheduler *pScheduler = pGraph->getScheduler();
00078     if (!pScheduler) {
00079         return;
00080     }
00081     pScheduler->checkAbort();
00082 }

ExecStreamBufProvision ExecStream::getOutputBufConversion (  )  const [virtual, inherited]

Queries the BufferProvision to which this stream needs its output to be converted, if any.

Returns:
required conversion; default is BUFPROV_NONE

Reimplemented in JavaTransformExecStream.

Definition at line 177 of file ExecStream.cpp.

References BUFPROV_NONE.

00178 {
00179     return BUFPROV_NONE;
00180 }

ExecStreamBufProvision ExecStream::getInputBufProvision (  )  const [virtual, inherited]

Queries the BufferProvision which this stream requires of its inputs when consuming their tuples.

Returns:
required model; default is BUFPROV_NONE

Reimplemented in ConfluenceExecStream, DoubleBufferExecStream, ScratchBufferExecStream, SegBufferExecStream, SegBufferWriterExecStream, SingleInputExecStream, and JavaTransformExecStream.

Definition at line 182 of file ExecStream.cpp.

References BUFPROV_NONE.

00183 {
00184     return BUFPROV_NONE;
00185 }

bool ClosableObject::isClosed (  )  const [inline, inherited]

Returns:
whether the object has been closed

Definition at line 58 of file ClosableObject.h.

00059     {
00060         return !needsClose;
00061     }

void ClosableObject::close (  )  [inherited]

Closes this object, releasing any unallocated resources.

Reimplemented in CollectExecStream, CorrelationJoinExecStream, LcsClusterAppendExecStream, and LcsClusterReplaceExecStream.

Definition at line 39 of file ClosableObject.cpp.

References ClosableObject::closeImpl(), and ClosableObject::needsClose.

Referenced by CacheImpl< PageT, VictimPolicyT >::allocatePages(), LcsRowScanBaseExecStream::closeImpl(), ExecStreamGraphImpl::closeImpl(), FlatFileBuffer::open(), ClosableObjectDestructor::operator()(), and Segment::~Segment().

00040 {
00041     if (!needsClose) {
00042         return;
00043     }
00044     needsClose = false;
00045     closeImpl();
00046 }

void TraceSource::initTraceSource ( SharedTraceTarget  pTraceTarget,
std::string  name 
) [virtual, inherited]

For use when initialization has to be deferred until after construction.

Parameters:
pTraceTarget the TraceTarget to which messages will be sent
name the name of this source

Definition at line 46 of file TraceSource.cpp.

References TraceSource::isTracing(), TraceSource::minimumLevel, TraceSource::name, TraceSource::pTraceTarget, and TRACE_OFF.

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

00049 {
00050     assert(!pTraceTarget.get());
00051 
00052     pTraceTarget = pTraceTargetInit;
00053     name = nameInit;
00054     if (isTracing()) {
00055         minimumLevel = pTraceTarget->getSourceTraceLevel(name);
00056     } else {
00057         minimumLevel = TRACE_OFF;
00058     }
00059 }

void TraceSource::trace ( TraceLevel  level,
std::string  message 
) const [inherited]

Records a trace message.

Normally only called via FENNEL_TRACE.

Parameters:
level severity level of event being trace
message the text of the message

Definition at line 61 of file TraceSource.cpp.

References TraceSource::getTraceTarget(), TraceSource::isTracing(), TraceSource::name, and TraceTarget::notifyTrace().

Referenced by Calculator::exec(), and ExecStreamScheduler::traceStreamBufferContents().

00062 {
00063     if (isTracing()) {
00064         getTraceTarget().notifyTrace(name,level,message);
00065     }
00066 }

bool TraceSource::isTracing (  )  const [inline, inherited]

Returns:
true iff tracing is enabled for this source

Definition at line 88 of file TraceSource.h.

Referenced by TraceSource::initTraceSource(), CalcExecStream::prepare(), and TraceSource::trace().

00089     {
00090         return pTraceTarget.get() ? true : false;
00091     }

bool TraceSource::isTracingLevel ( TraceLevel  level  )  const [inline, inherited]

Determines whether a particular level is being traced.

Parameters:
level trace level to test
Returns:
true iff tracing is enabled for the given level

Definition at line 100 of file TraceSource.h.

Referenced by ExecStreamScheduler::addGraph(), SimpleExecStreamGovernor::assignCachePages(), SimpleExecStreamGovernor::distributeCachePages(), Calculator::exec(), ExecStreamScheduler::ExecStreamScheduler(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterNodeWriter::moveFromTempToIndex(), JavaSinkExecStream::stuffByteBuffer(), and ExecStreamScheduler::traceStreamBuffers().

00101     {
00102         return level >= minimumLevel;
00103     }

TraceTarget& TraceSource::getTraceTarget (  )  const [inline, inherited]

Returns:
the TraceTarget for this source

Definition at line 108 of file TraceSource.h.

Referenced by TraceSource::trace().

00109     {
00110         assert(isTracing());
00111         return *(pTraceTarget.get());
00112     }

SharedTraceTarget TraceSource::getSharedTraceTarget (  )  const [inline, inherited]

Returns:
the SharedTraceTarget for this source

Definition at line 117 of file TraceSource.h.

Referenced by Database::init(), LcsClusterAppendExecStream::initLoad(), and CalcExecStream::prepare().

00118     {
00119         return pTraceTarget;
00120     }

std::string TraceSource::getTraceSourceName (  )  const [inline, inherited]

Gets the name of this source.

Useful to construct nested names for subcomponents that are also TraceSources.

Returns:
the name

Definition at line 127 of file TraceSource.h.

Referenced by LcsClusterAppendExecStream::initLoad().

00128     {
00129         return name;
00130     }

void TraceSource::setTraceSourceName ( std::string const &  n  )  [inline, inherited]

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 136 of file TraceSource.h.

00137     {
00138         name = n;
00139     }

TraceLevel TraceSource::getMinimumTraceLevel (  )  const [inline, inherited]

Definition at line 141 of file TraceSource.h.

00142     {
00143         return minimumLevel;
00144     }

void TraceSource::disableTracing (  )  [inherited]

Definition at line 68 of file TraceSource.cpp.

References TraceSource::minimumLevel, TraceSource::pTraceTarget, and TRACE_OFF.

Referenced by TestBase::afterTestCase().

00069 {
00070     pTraceTarget.reset();
00071     minimumLevel = TRACE_OFF;
00072 }

void ErrorSource::initErrorSource ( SharedErrorTarget  pErrorTarget,
const std::string &  name 
) [virtual, inherited]

For use when initialization has to be deferred until after construction.

Parameters:
pErrorTarget the ErrorTarget to which errors will be posted
name the name of this source

Definition at line 47 of file ErrorSource.cpp.

References ErrorSource::name, and ErrorSource::pErrorTarget.

Referenced by ErrorSource::ErrorSource().

00050 {
00051     pErrorTarget = pErrorTargetInit;
00052     name = nameInit;
00053 }

void ErrorSource::postError ( ErrorLevel  level,
const std::string &  message,
void *  address,
long  capacity,
int  index 
) [inherited]

Posts an exception, such as a row exception.

See also:
ErrorTarget for a description of the parameters

Definition at line 55 of file ErrorSource.cpp.

References ErrorSource::getErrorTarget(), ErrorSource::hasTarget(), ErrorSource::name, and ErrorTarget::notifyError().

Referenced by FlatFileExecStreamImpl::logError(), ErrorSource::postError(), and LbmSplicerExecStream::postViolation().

00058 {
00059     if (hasTarget()) {
00060         getErrorTarget().notifyError(
00061             name, level, message, address, capacity, index);
00062     }
00063 }

void ErrorSource::postError ( ErrorLevel  level,
const std::string &  message,
const TupleDescriptor &  errorDesc,
const TupleData &  errorTuple,
int  index 
) [inherited]

Posts an exception, such as a row exception.

See also:
ErrorTarget for a description of the parameters

Definition at line 65 of file ErrorSource.cpp.

References TupleAccessor::compute(), ErrorSource::errorAccessor, FixedBuffer, TupleAccessor::getByteCount(), TupleAccessor::getMaxByteCount(), ErrorSource::hasTarget(), TupleAccessor::marshal(), ErrorSource::pErrorBuf, and ErrorSource::postError().

00068 {
00069     if (!hasTarget()) {
00070         return;
00071     }
00072 
00073     if (!pErrorBuf) {
00074         errorAccessor.compute(errorDesc);
00075         uint cbMax = errorAccessor.getMaxByteCount();
00076         pErrorBuf.reset(new FixedBuffer[cbMax]);
00077     }
00078 
00079     uint cbTuple = errorAccessor.getByteCount(errorTuple);
00080     errorAccessor.marshal(errorTuple, pErrorBuf.get());
00081     postError(level, message, pErrorBuf.get(), cbTuple, index);
00082 }

bool ErrorSource::hasTarget (  )  const [inline, inherited]

Returns:
true iff an error target has been set

Definition at line 112 of file ErrorSource.h.

Referenced by ErrorSource::postError().

00113     {
00114         return pErrorTarget.get() ? true : false;
00115     }

ErrorTarget& ErrorSource::getErrorTarget (  )  const [inline, inherited]

Returns:
the ErrorTarget for this source

Definition at line 120 of file ErrorSource.h.

Referenced by ErrorSource::postError().

00121     {
00122         assert(hasTarget());
00123         return *(pErrorTarget.get());
00124     }

SharedErrorTarget ErrorSource::getSharedErrorTarget (  )  const [inline, inherited]

Returns:
the SharedErrorTarget for this source

Definition at line 129 of file ErrorSource.h.

00130     {
00131         return pErrorTarget;
00132     }

std::string ErrorSource::getErrorSourceName (  )  const [inline, inherited]

Gets the name of this source.

Useful to construct nested names for subcomponents that are also ErrorSources.

Returns:
the name

Definition at line 139 of file ErrorSource.h.

00140     {
00141         return name;
00142     }

void ErrorSource::setErrorSourceName ( std::string const &  n  )  [inline, inherited]

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 148 of file ErrorSource.h.

00149     {
00150         name = n;
00151     }

void ErrorSource::disableTarget (  )  [inherited]

Definition at line 84 of file ErrorSource.cpp.

References ErrorSource::pErrorTarget.

00085 {
00086     pErrorTarget.reset();
00087 }

ExecStreamResult ConduitExecStream::precheckConduitBuffers (  )  [protected, inherited]

Checks the state of the input and output buffers.

If input empty, requests production. If input EOS, propagates that to output buffer. If output full, returns EXECRC_OVERFLOW.

Returns:
result of precheck; anything but EXECRC_YIELD indicates that execution should terminate immediately with returned code

Definition at line 61 of file ConduitExecStream.cpp.

References EXECBUF_EMPTY, EXECBUF_EOS, EXECBUF_NONEMPTY, EXECBUF_OVERFLOW, EXECBUF_UNDERFLOW, EXECRC_BUF_OVERFLOW, EXECRC_BUF_UNDERFLOW, EXECRC_EOS, EXECRC_YIELD, SingleInputExecStream::pInAccessor, and SingleOutputExecStream::pOutAccessor.

Referenced by ExternalSortExecStreamImpl::execute(), FtrsTableWriterExecStream::execute(), BTreeSearchUniqueExecStream::execute(), execute(), BTreeInsertExecStream::execute(), UncollectExecStream::execute(), SortedAggExecStream::execute(), ReshapeExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), BernoulliSamplingExecStream::execute(), and CalcExecStream::execute().

00062 {
00063     switch (pInAccessor->getState()) {
00064     case EXECBUF_EMPTY:
00065         pInAccessor->requestProduction();
00066         return EXECRC_BUF_UNDERFLOW;
00067     case EXECBUF_UNDERFLOW:
00068         return EXECRC_BUF_UNDERFLOW;
00069     case EXECBUF_EOS:
00070         pOutAccessor->markEOS();
00071         return EXECRC_EOS;
00072     case EXECBUF_NONEMPTY:
00073     case EXECBUF_OVERFLOW:
00074         break;
00075     default:
00076         permAssert(false);
00077     }
00078     if (pOutAccessor->getState() == EXECBUF_OVERFLOW) {
00079         return EXECRC_BUF_OVERFLOW;
00080     }
00081     return EXECRC_YIELD;
00082 }

void ConduitExecStream::setOutputBufAccessors ( std::vector< SharedExecStreamBufAccessor > const &  outAccessors  )  [virtual, inherited]

Initializes the buffer accessors for outputs from this stream.

This method is only ever called once, before prepare.

Parameters:
outAccessors buffer accessors ordered by output stream

Reimplemented from SingleInputExecStream.

Definition at line 36 of file ConduitExecStream.cpp.

References SingleOutputExecStream::setOutputBufAccessors().

00038 {
00039     SingleOutputExecStream::setOutputBufAccessors(outAccessors);
00040 }

void ConduitExecStream::setInputBufAccessors ( std::vector< SharedExecStreamBufAccessor > const &  inAccessors  )  [virtual, inherited]

Initializes the buffer accessors for inputs to this stream.

This method is only ever called once, before prepare.

Parameters:
inAccessors buffer accessors ordered by input stream

Reimplemented from SingleInputExecStream.

Definition at line 30 of file ConduitExecStream.cpp.

References SingleInputExecStream::setInputBufAccessors().

00032 {
00033     SingleInputExecStream::setInputBufAccessors(inAccessors);
00034 }

void ConduitExecStream::prepare ( ConduitExecStreamParams const &  params  )  [virtual, inherited]

Definition at line 42 of file ConduitExecStream.cpp.

References SingleInputExecStream::pInAccessor, SingleOutputExecStream::pOutAccessor, SingleOutputExecStream::prepare(), and SingleInputExecStream::prepare().

Referenced by ExternalSortExecStreamImpl::prepare(), LcsClusterAppendExecStream::prepare(), LbmNormalizerExecStream::prepare(), LhxAggExecStream::prepare(), FtrsTableWriterExecStream::prepare(), prepare(), BTreeInsertExecStream::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SegBufferReaderExecStream::prepare(), SegBufferExecStream::prepare(), ScratchBufferExecStream::prepare(), ReshapeExecStream::prepare(), DoubleBufferExecStream::prepare(), CopyExecStream::prepare(), CollectExecStream::prepare(), BernoulliSamplingExecStream::prepare(), and CalcExecStream::prepare().

00043 {
00044     SingleInputExecStream::prepare(params);
00045 
00046     if (params.outputTupleDesc.empty()) {
00047         pOutAccessor->setTupleShape(
00048             pInAccessor->getTupleDesc(),
00049             pInAccessor->getTupleFormat());
00050     }
00051 
00052     SingleOutputExecStream::prepare(params);
00053 }

void SingleInputExecStream::prepare ( SingleInputExecStreamParams const &  params  )  [virtual, inherited]

Definition at line 44 of file SingleInputExecStream.cpp.

References SingleInputExecStream::getInputBufProvision(), SingleInputExecStream::pInAccessor, and ExecStream::prepare().

Referenced by JavaSinkExecStream::prepare(), MockConsumerExecStream::prepare(), DiffluenceExecStream::prepare(), and ConduitExecStream::prepare().

00045 {
00046     ExecStream::prepare(params);
00047 
00048     assert(pInAccessor);
00049     assert(pInAccessor->getProvision() == getInputBufProvision());
00050 }

ExecStreamBufProvision SingleInputExecStream::getInputBufProvision (  )  const [virtual, inherited]

Queries the BufferProvision which this stream requires of its inputs when consuming their tuples.

Returns:
required model; default is BUFPROV_NONE

Reimplemented from ExecStream.

Reimplemented in DoubleBufferExecStream, ScratchBufferExecStream, SegBufferExecStream, and SegBufferWriterExecStream.

Definition at line 62 of file SingleInputExecStream.cpp.

References BUFPROV_PRODUCER.

Referenced by SingleInputExecStream::prepare().

00063 {
00064     return BUFPROV_PRODUCER;
00065 }

Member Data Documentation

TupleProjectionAccessor BTreeSearchExecStream::inputKeyAccessor [protected]

Definition at line 117 of file BTreeSearchExecStream.h.

Referenced by prepare(), and readSearchKey().

TupleProjectionAccessor BTreeSearchExecStream::inputJoinAccessor [protected]

Definition at line 118 of file BTreeSearchExecStream.h.

Referenced by prepare(), and searchForKey().

TupleProjectionAccessor BTreeSearchExecStream::readerKeyAccessor [protected]

Definition at line 119 of file BTreeSearchExecStream.h.

Referenced by checkNextKey(), open(), and testInterval().

TupleProjectionAccessor BTreeSearchExecStream::directiveAccessor [protected]

Definition at line 120 of file BTreeSearchExecStream.h.

Referenced by prepare(), and readDirectives().

TupleProjectionAccessor BTreeSearchExecStream::upperBoundAccessor [protected]

Definition at line 121 of file BTreeSearchExecStream.h.

Referenced by prepare(), and readUpperBoundKey().

TupleDescriptor BTreeSearchExecStream::inputKeyDesc [protected]

Definition at line 122 of file BTreeSearchExecStream.h.

Referenced by checkNextKey(), open(), LbmSearchExecStream::prepare(), prepare(), BTreePrefetchSearchExecStream::prepare(), testInterval(), and BTreePrefetchSearchExecStream::testNonLeafInterval().

TupleDescriptor BTreeSearchExecStream::upperBoundDesc [protected]

Definition at line 122 of file BTreeSearchExecStream.h.

Referenced by prepare(), BTreePrefetchSearchExecStream::prepare(), and readUpperBoundKey().

TupleData BTreeSearchExecStream::inputKeyData [protected]

Definition at line 123 of file BTreeSearchExecStream.h.

Referenced by innerSearchLoop(), prepare(), readSearchKey(), LbmSearchExecStream::setAdditionalKeys(), BTreePrefetchSearchExecStream::setAdditionalKeys(), LbmSearchExecStream::setLowerBoundKey(), and BTreePrefetchSearchExecStream::setLowerBoundKey().

TupleData BTreeSearchExecStream::upperBoundData [protected]

Definition at line 123 of file BTreeSearchExecStream.h.

Referenced by checkNextKey(), BTreePrefetchSearchExecStream::getPrefetchSearchKey(), prepare(), readUpperBoundKey(), searchForKey(), BTreePrefetchSearchExecStream::setUpSearchKey(), and testInterval().

TupleData BTreeSearchExecStream::readerKeyData [protected]

Definition at line 123 of file BTreeSearchExecStream.h.

Referenced by checkNextKey(), prepare(), testInterval(), and BTreePrefetchSearchExecStream::testNonLeafInterval().

TupleData BTreeSearchExecStream::directiveData [protected]

Definition at line 123 of file BTreeSearchExecStream.h.

Referenced by prepare(), and readDirectives().

TupleData * BTreeSearchExecStream::pSearchKey [protected]

Definition at line 123 of file BTreeSearchExecStream.h.

Referenced by BTreePrefetchSearchExecStream::getPrefetchSearchKey(), innerSearchLoop(), readUpperBoundKey(), searchForKey(), LbmSearchExecStream::setAdditionalKeys(), BTreePrefetchSearchExecStream::setAdditionalKeys(), LbmSearchExecStream::setLowerBoundKey(), BTreePrefetchSearchExecStream::setLowerBoundKey(), and testInterval().

bool BTreeSearchExecStream::outerJoin [protected]

Definition at line 125 of file BTreeSearchExecStream.h.

Referenced by prepare(), and searchForKey().

bool BTreeSearchExecStream::preFilterNulls [protected]

Definition at line 126 of file BTreeSearchExecStream.h.

Referenced by prepare(), and searchForKey().

uint BTreeSearchExecStream::nJoinAttributes [protected]

Definition at line 127 of file BTreeSearchExecStream.h.

Referenced by innerFetchLoop(), prepare(), and searchForKey().

SearchEndpoint BTreeSearchExecStream::lowerBoundDirective [protected]

Definition at line 128 of file BTreeSearchExecStream.h.

Referenced by BTreePrefetchSearchExecStream::getNextPageForPrefetch(), BTreePrefetchSearchExecStream::getPrefetchSearchKey(), readDirectives(), searchForKey(), LbmSearchExecStream::setAdditionalKeys(), BTreePrefetchSearchExecStream::setUpSearchKey(), and testInterval().

SearchEndpoint BTreeSearchExecStream::upperBoundDirective [protected]

Definition at line 129 of file BTreeSearchExecStream.h.

Referenced by BTreePrefetchSearchExecStream::getPrefetchSearchKey(), readDirectives(), LbmSearchExecStream::setAdditionalKeys(), BTreePrefetchSearchExecStream::setUpSearchKey(), and testInterval().

bool BTreeSearchExecStream::leastUpper [protected]

Definition at line 130 of file BTreeSearchExecStream.h.

Referenced by BTreePrefetchSearchExecStream::getNextPageForPrefetch(), LbmSearchExecStream::prepare(), prepare(), searchForKey(), and testInterval().

std::vector<BTreeSearchKeyParameter> BTreeSearchExecStream::searchKeyParams [protected]

Definition at line 131 of file BTreeSearchExecStream.h.

Referenced by prepare(), readSearchKey(), and readUpperBoundKey().

boost::scoped_array<FixedBuffer> BTreeSearchExecStream::searchKeyBuffer [protected]

Definition at line 132 of file BTreeSearchExecStream.h.

bool BTreeSearchExecStream::dynamicKeysRead [protected]

Definition at line 133 of file BTreeSearchExecStream.h.

Referenced by open(), and readSearchKey().

TupleProjection BTreeSearchExecStream::searchKeyProj [protected]

Definition at line 134 of file BTreeSearchExecStream.h.

Referenced by prepare(), readSearchKey(), and searchForKey().

TupleProjection BTreeSearchExecStream::upperBoundKeyProj [protected]

Definition at line 134 of file BTreeSearchExecStream.h.

Referenced by prepare(), readUpperBoundKey(), and searchForKey().

SharedBTreeReader BTreeReadExecStream::pReader [protected, inherited]

Definition at line 59 of file BTreeReadExecStream.h.

Referenced by checkNextKey(), BTreeSearchUniqueExecStream::execute(), BTreeScanExecStream::execute(), innerFetchLoop(), innerSearchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), open(), BTreeScanExecStream::open(), BTreeReadExecStream::open(), and searchForKey().

TupleProjectionAccessor BTreeReadExecStream::projAccessor [protected, inherited]

Definition at line 60 of file BTreeReadExecStream.h.

Referenced by BTreeScanExecStream::execute(), innerFetchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), BTreeReadExecStream::open(), and searchForKey().

TupleData BTreeReadExecStream::tupleData [protected, inherited]

Definition at line 61 of file BTreeReadExecStream.h.

Referenced by BTreeSearchUniqueExecStream::execute(), BTreeScanExecStream::execute(), innerFetchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), BTreeReadExecStream::prepare(), and searchForKey().

TupleProjection BTreeReadExecStream::outputProj [protected, inherited]

Definition at line 62 of file BTreeReadExecStream.h.

Referenced by BTreeReadExecStream::open(), and BTreeReadExecStream::prepare().

BTreeDescriptor BTreeExecStream::treeDescriptor [protected, inherited]

Definition at line 113 of file BTreeExecStream.h.

Referenced by BTreeInsertExecStream::buildTree(), BTreeExecStream::closeImpl(), BTreeExecStream::copyParamsToDescriptor(), LcsClusterReplaceExecStream::getTupleForLoad(), LcsClusterAppendExecStream::initLoad(), LcsClusterReplaceExecStream::initTupleLoadParams(), BTreePrefetchSearchExecStream::innerSearchLoop(), BTreePrefetchSearchExecStream::newReader(), BTreeExecStream::newReader(), BTreeExecStream::newWriter(), LcsClusterReplaceExecStream::open(), open(), BTreePrefetchSearchExecStream::open(), BTreeInsertExecStream::open(), BTreeExecStream::open(), LcsClusterReplaceExecStream::prepare(), LcsClusterAppendExecStream::prepare(), LbmSearchExecStream::prepare(), LbmGeneratorExecStream::prepare(), prepare(), BTreeInsertExecStream::prepare(), BTreeExecStream::prepare(), and BTreeInsertExecStream::truncateTree().

SegmentAccessor BTreeExecStream::scratchAccessor [protected, inherited]

Reimplemented in LcsClusterAppendExecStream.

Definition at line 114 of file BTreeExecStream.h.

Referenced by LbmGeneratorExecStream::closeImpl(), BTreePrefetchSearchExecStream::closeImpl(), BTreeExecStream::newWriter(), LbmGeneratorExecStream::prepare(), BTreePrefetchSearchExecStream::prepare(), and BTreeExecStream::prepare().

BTreeOwnerRootMap* BTreeExecStream::pRootMap [protected, inherited]

Definition at line 115 of file BTreeExecStream.h.

Referenced by BTreeExecStream::closeImpl(), BTreeExecStream::open(), and BTreeExecStream::prepare().

SharedBTreeAccessBase BTreeExecStream::pBTreeAccessBase [protected, inherited]

Definition at line 116 of file BTreeExecStream.h.

Referenced by BTreeInsertExecStream::closeImpl(), BTreeExecStream::closeImpl(), BTreePrefetchSearchExecStream::newReader(), BTreeExecStream::newReader(), BTreeExecStream::newWriter(), and BTreeExecStream::open().

SharedBTreeReader BTreeExecStream::pBTreeReader [protected, inherited]

Definition at line 117 of file BTreeExecStream.h.

Referenced by BTreeExecStream::endSearch(), BTreePrefetchSearchExecStream::newReader(), BTreeExecStream::newReader(), and BTreeExecStream::newWriter().

DynamicParamId BTreeExecStream::rootPageIdParamId [protected, inherited]

Definition at line 118 of file BTreeExecStream.h.

Referenced by open(), BTreeInsertExecStream::open(), BTreeInsertExecStream::prepare(), and BTreeExecStream::prepare().

SharedExecStreamBufAccessor SingleOutputExecStream::pOutAccessor [protected, inherited]

Definition at line 56 of file SingleOutputExecStream.h.

Referenced by LcsClusterAppendExecStream::compress(), ExternalSortExecStreamImpl::execute(), LcsRowScanExecStream::execute(), LbmUnionExecStream::execute(), LbmNormalizerExecStream::execute(), LbmGeneratorExecStream::execute(), LbmChopperExecStream::execute(), LhxJoinExecStream::execute(), LhxAggExecStream::execute(), FtrsTableWriterExecStream::execute(), BTreeSortExecStream::execute(), BTreeSearchUniqueExecStream::execute(), BTreeScanExecStream::execute(), BTreePrefetchSearchExecStream::execute(), BTreeInsertExecStream::execute(), FlatFileExecStreamImpl::execute(), ValuesExecStream::execute(), UncollectExecStream::execute(), SortedAggExecStream::execute(), SegBufferReaderExecStream::execute(), ScratchBufferExecStream::execute(), ReshapeExecStream::execute(), MockResourceExecStream::execute(), MockProducerExecStream::execute(), MergeExecStream::execute(), DoubleBufferExecStream::execute(), CorrelationJoinExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), CartesianJoinExecStream::execute(), BernoulliSamplingExecStream::execute(), BarrierExecStream::execute(), CalcExecStream::execute(), LbmGeneratorExecStream::flushEntry(), MockProducerExecStream::getProducedRowCount(), ExternalSortExecStreamImpl::getResourceRequirements(), innerFetchLoop(), LbmUnionExecStream::open(), LbmChopperExecStream::open(), LbmBitOpExecStream::open(), SingleOutputExecStream::open(), SegBufferReaderExecStream::open(), SegBufferExecStream::open(), ScratchBufferExecStream::open(), DoubleBufferExecStream::open(), CollectExecStream::open(), SegBufferExecStream::openBufferForRead(), ConduitExecStream::precheckConduitBuffers(), LcsRowScanExecStream::prepare(), LcsRowScanBaseExecStream::prepare(), LcsClusterAppendExecStream::prepare(), LbmUnionExecStream::prepare(), LbmGeneratorExecStream::prepare(), LhxJoinExecStream::prepare(), LhxAggExecStream::prepare(), FtrsTableWriterExecStream::prepare(), FlatFileExecStreamImpl::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SingleOutputExecStream::prepare(), ReshapeExecStream::prepare(), MockResourceExecStream::prepare(), MockProducerExecStream::prepare(), MergeExecStream::prepare(), CorrelationJoinExecStream::prepare(), ConduitExecStream::prepare(), CollectExecStream::prepare(), CartesianJoinExecStream::prepare(), BernoulliSamplingExecStream::prepare(), BarrierExecStream::prepare(), CalcExecStream::prepare(), SortedAggExecStream::produce(), LbmBitOpExecStream::producePendingOutput(), LbmUnionExecStream::produceTuple(), LbmNormalizerExecStream::produceTuple(), LbmMinusExecStream::produceTuple(), LbmChopperExecStream::produceTuple(), LbmBitOpExecStream::produceTuple(), LbmBitOpExecStream::readInput(), LbmMinusExecStream::readMinuendInput(), and SingleOutputExecStream::setOutputBufAccessors().

bool ExecStream::isOpen [protected, inherited]

Whether this stream is currently open.

Note that this is not quite the opposite of the inherited ClosableObject.needsClose, since a stream needs to be closed before destruction if it has been prepared but never opened.

Definition at line 61 of file ExecStream.h.

Referenced by ExecStream::closeImpl(), ExecStream::ExecStream(), and ExecStream::open().

ExecStreamGraph* ExecStream::pGraph [protected, inherited]

Dataflow graph containing this stream.

Note that we don't use a weak_ptr for this because it needs to be accessed frequently during execution, and the extra locking overhead would be frivolous.

Definition at line 68 of file ExecStream.h.

Referenced by ExecStream::checkAbort(), ExecStream::ExecStream(), CorrelationJoinExecStream::execute(), ExecStream::getGraph(), JavaTransformExecStream::open(), SingleInputExecStream::open(), MergeExecStream::open(), ExecStream::open(), CorrelationJoinExecStream::open(), ConfluenceExecStream::open(), ExecStream::prepare(), CartesianJoinExecStream::prepare(), and LbmMinusExecStream::restartSubtrahends().

ExecStreamId ExecStream::id [protected, inherited]

Identifier for this stream; local to its containing graph.

Definition at line 73 of file ExecStream.h.

Referenced by ExecStream::getStreamId().

std::string ExecStream::name [protected, inherited]

Name of stream, as known by optimizer.

Reimplemented from TraceSource.

Definition at line 78 of file ExecStream.h.

Referenced by ExecStream::ExecStream(), ExecStream::getName(), FlatFileExecStreamImpl::open(), and ExecStream::setName().

SharedDynamicParamManager ExecStream::pDynamicParamManager [protected, inherited]

The dynamic parameter manager available to this stream.

(Obtained at prepare() time. Keep a shared pointer in case the stream is reassigned to another graph for execution; cf ExecStreamGraph::mergeFrom())

Definition at line 85 of file ExecStream.h.

Referenced by CorrelationJoinExecStream::close(), SegBufferReaderExecStream::closeImpl(), LbmUnionExecStream::execute(), LbmSplicerExecStream::execute(), LbmGeneratorExecStream::execute(), LbmChopperExecStream::execute(), CorrelationJoinExecStream::execute(), BarrierExecStream::execute(), LcsClusterReplaceExecStream::open(), LbmUnionExecStream::open(), LbmSplicerExecStream::open(), LbmGeneratorExecStream::open(), LbmBitOpExecStream::open(), open(), BTreeInsertExecStream::open(), SegBufferWriterExecStream::open(), SegBufferReaderExecStream::open(), NestedLoopJoinExecStream::open(), CorrelationJoinExecStream::open(), ExecStream::prepare(), CalcExecStream::prepare(), NestedLoopJoinExecStream::processLeftInput(), LbmSearchExecStream::reachedTupleLimit(), ReshapeExecStream::readDynamicParams(), SegBufferWriterExecStream::readReaderRefCount(), readSearchKey(), readUpperBoundKey(), LbmSearchExecStream::setAdditionalKeys(), and LbmBitOpExecStream::writeStartRidParamValue().

SharedLogicalTxn ExecStream::pTxn [protected, inherited]

The transaction embracing the stream.

Obtained at open() time; but not released at close() time, to allow TableWriters to replay a txn. Keep a shared pointer in case the stream is reassigned to another graph for execution; cf ExecStreamGraph::mergeFrom())

Definition at line 94 of file ExecStream.h.

Referenced by FtrsTableWriterExecStream::commitSavepoint(), FtrsTableWriterExecStream::createSavepoint(), FtrsTableWriterExecStream::open(), ExecStream::open(), and FtrsTableWriterExecStream::rollbackSavepoint().

ExecStreamResourceQuantity ExecStream::resourceAllocation [protected, inherited]

Resource quantities currently allocated to this stream.

Definition at line 100 of file ExecStream.h.

Referenced by ExecStream::setResourceAllocation().

SharedCacheAccessor ExecStream::pQuotaAccessor [protected, inherited]

CacheAccessor used for quota tracking.

Definition at line 105 of file ExecStream.h.

Referenced by ExecStream::open(), ExecStream::prepare(), and ExecStream::setResourceAllocation().

SharedCacheAccessor ExecStream::pScratchQuotaAccessor [protected, inherited]

CacheAccessor used for scratch page quota tracking.

Definition at line 110 of file ExecStream.h.

Referenced by ExecStream::open(), ExecStream::prepare(), and ExecStream::setResourceAllocation().

bool ClosableObject::needsClose [protected, inherited]

Definition at line 44 of file ClosableObject.h.

Referenced by SegStreamAllocation::beginWrite(), ExecStreamGraphImpl::clear(), ClosableObject::ClosableObject(), ClosableObject::close(), FlatFileBuffer::open(), ExecStreamGraphImpl::open(), ExecStream::open(), and ClosableObject::~ClosableObject().

SharedExecStreamBufAccessor SingleInputExecStream::pInAccessor [protected, inherited]

Definition at line 51 of file SingleInputExecStream.h.

Referenced by SortedAggExecStream::compareGroupByKeys(), ExternalSortExecStreamImpl::computeFirstResult(), ExternalSortExecStreamImpl::execute(), LbmSplicerExecStream::execute(), FtrsTableWriterExecStream::execute(), BTreeSortExecStream::execute(), BTreeSearchUniqueExecStream::execute(), execute(), BTreePrefetchSearchExecStream::execute(), BTreeInsertExecStream::execute(), JavaSinkExecStream::execute(), UncollectExecStream::execute(), SplitterExecStream::execute(), SortedAggExecStream::execute(), SegBufferWriterExecStream::execute(), SegBufferReaderExecStream::execute(), SegBufferExecStream::execute(), ScratchBufferExecStream::execute(), ReshapeExecStream::execute(), MockConsumerExecStream::execute(), DoubleBufferExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), BernoulliSamplingExecStream::execute(), CalcExecStream::execute(), BTreePrefetchSearchExecStream::getNextPageForPrefetch(), LcsClusterReplaceExecStream::getTupleForLoad(), LcsClusterAppendExecStream::getTupleForLoad(), LbmSplicerExecStream::getValidatedTuple(), LcsClusterReplaceExecStream::initTupleLoadParams(), innerSearchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), LcsClusterReplaceExecStream::open(), LbmNormalizerExecStream::open(), SingleInputExecStream::open(), SegBufferWriterExecStream::open(), SegBufferExecStream::open(), ScratchBufferExecStream::open(), MockConsumerExecStream::open(), DoubleBufferExecStream::open(), CollectExecStream::open(), LcsClusterAppendExecStream::postProcessTuple(), ConduitExecStream::precheckConduitBuffers(), ExternalSortExecStreamImpl::prepare(), LcsClusterAppendExecStream::prepare(), LbmSplicerExecStream::prepare(), LbmNormalizerExecStream::prepare(), prepare(), BTreeInsertExecStream::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SingleInputExecStream::prepare(), SegBufferReaderExecStream::prepare(), ReshapeExecStream::prepare(), DiffluenceExecStream::prepare(), ConduitExecStream::prepare(), CollectExecStream::prepare(), BernoulliSamplingExecStream::prepare(), CalcExecStream::prepare(), SortedAggExecStream::produce(), readSearchKey(), LhxAggExecStream::setAggComputers(), LhxAggExecStream::setHashInfo(), SingleInputExecStream::setInputBufAccessors(), and JavaSinkExecStream::stuffByteBuffer().

The documentation for this class was generated from the following files:
Generated on Mon Jun 22 04:00:26 2009 for Fennel by  doxygen 1.5.1