Fennel: LcsClusterReplaceExecStream Class Reference (original) (raw)
Given a stream of tuples corresponding to the column values in a cluster, creates a new cluster, replacing the pre-existing cluster with the new input tuples. More...
#include <[LcsClusterReplaceExecStream.h](LcsClusterReplaceExecStream%5F8h-source.html)>
Inheritance diagram for LcsClusterReplaceExecStream:
| Public Member Functions | |
|---|---|
| virtual void | prepare (LcsClusterReplaceExecStreamParams const ¶ms) |
| virtual void | open (bool restart) |
| Opens this stream, acquiring any resources needed in order to be able to fetch data. | |
| virtual void | getResourceRequirements (ExecStreamResourceQuantity &minQuantity, ExecStreamResourceQuantity &optQuantity) |
| virtual void | prepare (LcsClusterAppendExecStreamParams const ¶ms) |
| virtual void | prepare (BTreeExecStreamParams const ¶ms) |
| virtual void | prepare (SingleOutputExecStreamParams const ¶ms) |
| virtual void | prepare (ExecStreamParams const ¶ms) |
| Prepares this stream for execution. | |
| virtual void | prepare (ConduitExecStreamParams const ¶ms) |
| virtual void | prepare (SingleInputExecStreamParams const ¶ms) |
| virtual ExecStreamResult | execute (ExecStreamQuantum const &quantum) |
| Executes this stream. | |
| virtual void | getResourceRequirements (ExecStreamResourceQuantity &minQuantity, ExecStreamResourceQuantity &optQuantity, ExecStreamResourceSettingType &optType) |
| Determines resource requirements for this stream. | |
| virtual void | closeImpl () |
| Implements ClosableObject. | |
| virtual ExecStreamBufProvision | getOutputBufProvision () const |
| Queries the BufferProvision which this stream is capable of when producing tuples. | |
| virtual void | setInputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &inAccessors) |
| Initializes the buffer accessors for inputs to 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 void | setOutputBufAccessors (std::vector< SharedExecStreamBufAccessor > const &outAccessors) |
| Initializes the buffer accessors for outputs from this stream. | |
| 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. | |
| 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 | |
| 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 () |
| Static Public Member Functions | |
| static SharedBTreeWriter | newWriter (BTreeExecStreamParams const ¶ms) |
| static void | copyParamsToDescriptor (BTreeDescriptor &, BTreeParams const &, SharedCacheAccessor const &) |
| Protected Member Functions | |
| void | allocArrays () |
| Allocate memory for arrays. | |
| void | initLoad () |
| Initializes the load. | |
| void | loadExistingBlock () |
| Populates row and hash arrays from existing index block. | |
| void | startNewBlock () |
| Prepare to write a fresh block. | |
| void | convertTuplesToCols () |
| Given a TupleData representing all columns in a cluster, converts each column into its own TupleData. | |
| void | addValueOrdinal (uint column, uint16_t vOrd) |
| Adds value ordinal to row array for new row. | |
| bool | isRowArrayFull () |
| True if row array is full. | |
| void | writeBatch (bool lastBatch) |
| Writes a batch(run) to index block. | |
| void | writeBlock () |
| Writes block to index when the block is full or this is the last block in the load. | |
| bool | getLastBlock (PLcsClusterNode &pBlock) |
| Gets last block written to disk so we can append to it, reading in the first rid value stored on the page. | |
| void | init () |
| Initializes and sets up object with content specific to the load that will be carried out. | |
| ExecStreamResult | compress (ExecStreamQuantum const &quantum) |
| Processes rows for loading. | |
| 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 | |
| uint | blockSize |
| Space available on page blocks for writing cluster data. | |
| TupleDescriptor | tableColsTupleDesc |
| Tuple descriptor for the tuple representing all cluster columns across the table that this cluster is a part of. | |
| TupleData | clusterColsTupleData |
| Tuple data for the tuple datums representing only this cluster. | |
| TupleDescriptor | clusterColsTupleDesc |
| Tuple descriptors for the columns that are part of this cluster. | |
| boost::scoped_array< TupleDescriptor > | colTupleDesc |
| Individual tuple descriptors for each column in the cluster. | |
| SegmentAccessor | scratchAccessor |
| Scratch accessor for allocating large buffer pages. | |
| ClusterPageLock | bufferLock |
| Lock on scratch page. | |
| bool | overwrite |
| True if overwriting all existing data. | |
| bool | isDone |
| Whether row count has been produced. | |
| TupleData | outputTuple |
| Output tuple containing count of number of rows loaded. | |
| TupleAccessor * | outputTupleAccessor |
| A reference to the output accessor contained in SingleOutputExecStream::pOutAccessor. | |
| boost::scoped_array< FixedBuffer > | outputTupleBuffer |
| buffer holding the outputTuple to provide to the consumers | |
| bool | compressCalled |
| True if execute has been called at least once. | |
| boost::scoped_array< LcsHash > | hash |
| Array of hashes, one per cluster column. | |
| uint | numColumns |
| Number of columns in the cluster. | |
| boost::scoped_array< PBuffer > | rowBlock |
| Array of temporary blocks for row array. | |
| uint | nRowsMax |
| Maximum number of values that can be stored in m_rowBlock. | |
| boost::scoped_array< PBuffer > | hashBlock |
| Array of temporary blocks for hash table. | |
| boost::scoped_array< PBuffer > | builderBlock |
| Array of temporary blocks used by ClusterNodeWriter. | |
| uint | rowCnt |
| Number of rows loaded into the current set of batches. | |
| bool | indexBlockDirty |
| True if index blocks need to be written to disk. | |
| LcsRid | firstRow |
| Starting rowid in a cluster page. | |
| LcsRid | lastRow |
| Last rowid in the last batch. | |
| LcsRid | startRow |
| SharedLcsClusterNodeWriter | lcsBlockBuilder |
| Page builder object. | |
| boost::scoped_array< LcsHashValOrd > | hashValOrd |
| Row value ordinal returned from hash, one per cluster column. | |
| boost::scoped_array< boost::scoped_array< FixedBuffer > > | tempBuf |
| Temporary buffers used by WriteBatch. | |
| boost::scoped_array< uint > | maxValueSize |
| Max size for each column cluster used by WriteBatch. | |
| bool | arraysAlloced |
| Indicates where or not we have already allocated arrays. | |
| PLcsClusterNode | pIndexBlock |
| Buffer pointing to cluster page that will actually be written. | |
| RecordNum | numRowCompressed |
| Total number of rows loaded by this object. | |
| BTreeDescriptor | treeDescriptor |
| 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 Member Functions | |
| virtual void | initTupleLoadParams (const TupleProjection &inputProj) |
| Initializes member fields corresponding to the data to be loaded, taking into account the extra rid column that identifies each input tuple. | |
| virtual ExecStreamResult | getTupleForLoad () |
| Retrieves the tuple that will be loaded into the cluster. | |
| virtual void | postProcessTuple () |
| Performs post-processing after a tuple has been loaded. | |
| void | readOrigClusterRow () |
| Reads the cluster columns for the current row being loaded from the original cluster. | |
| virtual void | close () |
| Writes out the last pending batches and btree pages. | |
| Private Attributes | |
| DynamicParamId | newClusterRootParamId |
| Dynamic parameter id corresponding to the root pageId of the new cluster, if the pageId is required downstream. | |
| TupleDescriptor | projInputTupleDesc |
| Tuple descriptor representing the rid column plus the cluster columns to be loaded. | |
| TupleData | projInputTupleData |
| Tuple data for the projected input tuple. | |
| std::vector< UnalignedAttributeAccessor > | attrAccessors |
| Accessors for loading column values from the original cluster. | |
| SnapshotRandomAllocationSegment * | pSnapshotSegment |
| The underlying snapshot segment for the cluster. | |
| SharedLcsClusterReader | pOrigClusterReader |
| Reader for the original cluster. | |
| RecordNum | origNumRows |
| Number of rows in the original cluster. | |
| PageId | origRootPageId |
| The rootPageId of the original rid to pageId btree map. | |
| LcsRid | currLoadRid |
| The current rid being loaded. | |
| bool | needTuple |
| True if a new tuple needs to be provided for the load. | |
| LcsRid | currInputRid |
| The rid value of the last input row read. | |
| TupleProjectionAccessor | clusterColsTupleAccessor |
| Accessor for projecting cluster tuple data from the input row. | |
| TupleDataWithBuffer | origClusterTupleData |
| TupleData used to load column values from the original cluster. | |
| bool | newData |
| True if at least one existing row is being replaced with a new value. |
Detailed Description
Given a stream of tuples corresponding to the column values in a cluster, creates a new cluster, replacing the pre-existing cluster with the new input tuples.
Each tuple contains in its first column a rid value that identifies which row will be replaced. If there are gaps in the rid sequence, then the row corresponding to that gap will be replaced with a tuple that has the same values as the existing tuple in the original cluster at that same rid position.
After processing all input, the rid to cluster pageId btree map corresponding to the cluster is versioned off of the original btree's rootPageId. So, this execution stream requires the underlying segment corresponding to the cluster to be a snapshot segment.
Definition at line 53 of file LcsClusterReplaceExecStream.h.
Member Function Documentation
| void LcsClusterReplaceExecStream::initTupleLoadParams | ( | const TupleProjection & | inputProj | ) | [private, virtual] |
|---|
Initializes member fields corresponding to the data to be loaded, taking into account the extra rid column that identifies each input tuple.
Parameters:
| inputProj | projection of the input tuple that's relevant to this cluster append |
|---|
Reimplemented from LcsClusterAppendExecStream.
Definition at line 42 of file LcsClusterReplaceExecStream.cpp.
References attrAccessors, TupleProjectionAccessor::bind(), clusterColsTupleAccessor, LcsClusterAppendExecStream::clusterColsTupleData, LcsClusterAppendExecStream::clusterColsTupleDesc, LcsClusterAppendExecStream::colTupleDesc, TupleData::compute(), TupleDataWithBuffer::computeAndAllocate(), LcsClusterAppendExecStream::numColumns, origClusterTupleData, SingleInputExecStream::pInAccessor, pOrigClusterReader, TupleDescriptor::projectFrom(), projInputTupleData, projInputTupleDesc, LcsClusterAppendExecStream::tableColsTupleDesc, and BTreeExecStream::treeDescriptor.
| ExecStreamResult LcsClusterReplaceExecStream::getTupleForLoad | ( | | ) | [private, virtual] | | -------------------------------------------------------------------------------------------------------------------------- | - | | - | -------------------- |
Retrieves the tuple that will be loaded into the cluster.
The tuple either originates from the input stream or contains the original values at the current rid position being loaded.
Reimplemented from LcsClusterAppendExecStream.
Definition at line 148 of file LcsClusterReplaceExecStream.cpp.
References clusterColsTupleAccessor, LcsClusterAppendExecStream::clusterColsTupleData, BTreeBuilder::createEmptyRoot(), currInputRid, currLoadRid, EXECBUF_EOS, EXECRC_BUF_UNDERFLOW, EXECRC_EOS, EXECRC_YIELD, BTreeAccessBase::getRootPageId(), LcsClusterAppendExecStream::initLoad(), needTuple, newData, NULL_PAGE_ID, opaqueToInt(), origNumRows, origRootPageId, SingleInputExecStream::pInAccessor, projInputTupleData, SegmentAccessor::pSegment, pSnapshotSegment, readOrigClusterRow(), BTreeDescriptor::rootPageId, BTreeDescriptor::segmentAccessor, BTreeExecStream::treeDescriptor, TupleProjectionAccessor::unmarshal(), and SnapshotRandomAllocationSegment::versionPage().
| void LcsClusterReplaceExecStream::postProcessTuple | ( | | ) | [private, virtual] | | -------------------------------------------------- | - | | - | -------------------- |
| void LcsClusterReplaceExecStream::readOrigClusterRow | ( | | ) | [private] | | ---------------------------------------------------- | - | | - | ----------- |
| void LcsClusterReplaceExecStream::close | ( | | ) | [private, virtual] | | --------------------------------------- | - | | - | -------------------- |
| void LcsClusterReplaceExecStream::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 LcsClusterAppendExecStream.
Definition at line 105 of file LcsClusterReplaceExecStream.cpp.
References TupleDatum::cbData, currInputRid, currLoadRid, SegmentFactory::getSnapshotSegment(), MAXU, needTuple, newClusterRootParamId, newData, opaqueToInt(), LcsClusterAppendExecStream::open(), origNumRows, TupleDatum::pData, ExecStream::pDynamicParamManager, SingleInputExecStream::pInAccessor, pOrigClusterReader, SegmentAccessor::pSegment, pSnapshotSegment, BTreeDescriptor::rootPageId, BTreeDescriptor::segmentAccessor, and BTreeExecStream::treeDescriptor.
| void LcsClusterAppendExecStream::allocArrays | ( | | ) | [protected, inherited] | | -------------------------------------------- | - | | - | ------------------------ |
| void LcsClusterAppendExecStream::initLoad | ( | | ) | [protected, inherited] | | ----------------------------------------- | - | | - | ------------------------ |
Initializes the load.
This method should only be called when the input stream has data available to read.
Definition at line 285 of file LcsClusterAppendExecStream.cpp.
References LcsClusterAppendExecStream::allocArrays(), SegNodeLock< Node >::allocatePage(), LcsClusterAppendExecStream::blockSize, LcsClusterAppendExecStream::bufferLock, LcsClusterAppendExecStream::builderBlock, LcsClusterAppendExecStream::clusterColsTupleDesc, LcsClusterAppendExecStream::colTupleDesc, LcsClusterAppendExecStream::compressCalled, LcsClusterAppendExecStream::getLastBlock(), SegPageLock::getPage(), TraceSource::getSharedTraceTarget(), TraceSource::getTraceSourceName(), CachePage::getWritableData(), LcsClusterAppendExecStream::hash, LcsClusterAppendExecStream::hashBlock, LcsClusterAppendExecStream::lcsBlockBuilder, LcsClusterAppendExecStream::loadExistingBlock(), LcsClusterAppendExecStream::nRowsMax, LcsClusterAppendExecStream::numColumns, LcsClusterAppendExecStream::pIndexBlock, LcsClusterAppendExecStream::rowBlock, LcsClusterAppendExecStream::scratchAccessor, LcsClusterAppendExecStream::startNewBlock(), LcsClusterAppendExecStream::startRow, BTreeExecStream::treeDescriptor, and SegPageLock::unlock().
Referenced by getTupleForLoad(), and LcsClusterAppendExecStream::getTupleForLoad().
| void LcsClusterAppendExecStream::loadExistingBlock | ( | | ) | [protected, inherited] | | -------------------------------------------------- | - | | - | ------------------------ |
Populates row and hash arrays from existing index block.
Definition at line 418 of file LcsClusterAppendExecStream.cpp.
References LcsClusterAppendExecStream::addValueOrdinal(), LcsClusterAppendExecStream::blockSize, LcsClusterAppendExecStream::builderBlock, LcsClusterAppendExecStream::firstRow, FixedBuffer, LcsHashValOrd::getValOrd(), LcsClusterAppendExecStream::hash, LcsClusterAppendExecStream::indexBlockDirty, LcsClusterAppendExecStream::lastRow, LcsClusterAppendExecStream::lcsBlockBuilder, LcsClusterAppendExecStream::numColumns, LcsClusterAppendExecStream::pIndexBlock, LcsClusterAppendExecStream::rowCnt, LcsClusterAppendExecStream::startNewBlock(), LcsClusterAppendExecStream::startRow, and LcsClusterAppendExecStream::writeBlock().
Referenced by LcsClusterAppendExecStream::initLoad().
00419 {
00420 boost::scoped_array numVals;
00421 boost::scoped_array lastValOff;
00422 boost::scoped_array<boost::scoped_array > aLeftOverBufs;
00423
00424
00425
00426 uint anLeftOvers;
00427
00428
00429
00430 boost::scoped_array aiFixedSize;
00431
00432
00433 LcsHashValOrd vOrd;
00434
00435 uint i, j;
00436 RecordNum startRowCnt;
00437 RecordNum nrows;
00438
00439 lcsBlockBuilder->init(
00440 numColumns, reinterpret_cast<uint8_t *> (pIndexBlock),
00441 builderBlock.get(), blockSize);
00442
00443 lastValOff.reset(new uint16_t[numColumns]);
00444 numVals.reset(new uint[numColumns]);
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456 bool bStartNewBlock =
00457 lcsBlockBuilder->openAppend(numVals.get(), lastValOff.get(), nrows);
00458 lastRow = firstRow + nrows;
00459 startRow = lastRow;
00460
00461
00462 aiFixedSize.reset(new uint[numColumns]);
00463 aLeftOverBufs.reset(new boost::scoped_array[numColumns]);
00464
00465 startRowCnt = rowCnt;
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478 for (i = 0; i < numColumns; i++) {
00479
00480 rowCnt = startRowCnt;
00481 lcsBlockBuilder->describeLastBatch(i, anLeftOvers, aiFixedSize[i]);
00482
00483
00484
00485
00486 if (anLeftOvers > 0) {
00487 aLeftOverBufs[i].reset(
00488 new FixedBuffer[anLeftOvers * aiFixedSize[i]]);
00489 lcsBlockBuilder->rollBackLastBatch(i, aLeftOverBufs[i].get());
00490 indexBlockDirty = true;
00491 }
00492 }
00493
00494
00495 lastRow -= anLeftOvers;
00496
00497
00498 if (bStartNewBlock) {
00499 writeBlock();
00500 startNewBlock();
00501 }
00502
00503
00504 for (i = 0; i < numColumns; i++) {
00505
00506 rowCnt = startRowCnt;
00507
00508 if (!bStartNewBlock) {
00509
00510
00511
00512
00513
00514 hash[i].restore(numVals[i], lastValOff[i]);
00515 }
00516
00517
00518
00519
00520 if (anLeftOvers > 0) {
00521 uint8_t *val;
00522 bool undoInsert = false;
00523
00524
00525
00526
00527
00528
00529 if (hash[i].isHashFull(anLeftOvers)) {
00530 hash[i].startNewBatch(anLeftOvers);
00531 }
00532
00533 for (j = 0, val = aLeftOverBufs[i].get();
00534 j < anLeftOvers;
00535 j++, val += aiFixedSize[i])
00536 {
00537 hash[i].insert(val, &vOrd, &undoInsert);
00538
00539
00540 assert(!undoInsert);
00541 addValueOrdinal(i, vOrd.getValOrd());
00542 rowCnt++;
00543 }
00544 }
00545 }
00546 }
| void LcsClusterAppendExecStream::startNewBlock | ( | | ) | [protected, inherited] | | ---------------------------------------------- | - | | - | ------------------------ |
Prepare to write a fresh block.
Definition at line 378 of file LcsClusterAppendExecStream.cpp.
References LcsClusterAppendExecStream::blockSize, LcsClusterAppendExecStream::builderBlock, LcsClusterAppendExecStream::colTupleDesc, LcsClusterAppendExecStream::firstRow, LcsClusterAppendExecStream::hash, LcsClusterAppendExecStream::hashBlock, LcsClusterAppendExecStream::indexBlockDirty, LcsClusterAppendExecStream::init(), LcsClusterAppendExecStream::lastRow, LcsClusterAppendExecStream::lcsBlockBuilder, LcsClusterAppendExecStream::numColumns, LcsClusterAppendExecStream::pIndexBlock, and LcsClusterAppendExecStream::rowCnt.
Referenced by LcsClusterAppendExecStream::initLoad(), LcsClusterAppendExecStream::loadExistingBlock(), and LcsClusterAppendExecStream::writeBatch().
| void LcsClusterAppendExecStream::convertTuplesToCols | ( | | ) | [protected, inherited] | | ---------------------------------------------------- | - | | - | ------------------------ |
Given a TupleData representing all columns in a cluster, converts each column into its own TupleData.
| void LcsClusterAppendExecStream::addValueOrdinal | ( | uint | column, |
|---|---|---|---|
| uint16_t | vOrd | ||
| ) | [protected, inherited] |
| bool LcsClusterAppendExecStream::isRowArrayFull | ( | | ) | [protected, inherited] | | ----------------------------------------------- | - | | - | ------------------------ |
| void LcsClusterAppendExecStream::writeBatch | ( | bool | lastBatch | ) | [protected, inherited] |
|---|
Writes a batch(run) to index block.
Batches have a multiple of 8 rows.
Parameters:
| lastBatch | true if last batch |
|---|
Definition at line 566 of file LcsClusterAppendExecStream.cpp.
References LcsClusterAppendExecStream::addValueOrdinal(), count(), FixedBuffer, LcsClusterAppendExecStream::hash, LcsClusterAppendExecStream::lastRow, LCS_FIXED, LCS_VARIABLE, LcsClusterAppendExecStream::lcsBlockBuilder, LcsClusterAppendExecStream::maxValueSize, LcsClusterAppendExecStream::numColumns, LcsClusterAppendExecStream::rowBlock, LcsClusterAppendExecStream::rowCnt, LcsClusterAppendExecStream::startNewBlock(), LcsClusterAppendExecStream::tempBuf, and LcsClusterAppendExecStream::writeBlock().
Referenced by LcsClusterAppendExecStream::compress(), and LcsClusterAppendExecStream::writeBlock().
00567 {
00568 uint16_t *oVals;
00569 uint leftOvers;
00570 PBuffer val;
00571 LcsBatchMode mode;
00572 uint i, j;
00573 uint origRowCnt, count = 0;
00574
00575 lastRow += rowCnt;
00576
00577 for (origRowCnt = rowCnt, i = 0; i < numColumns; i++) {
00578 rowCnt = origRowCnt;
00579
00580
00581 maxValueSize[i] = hash[i].getMaxValueSize();
00582
00583
00584 lcsBlockBuilder->pickCompressionMode(
00585 i, maxValueSize[i], rowCnt, &oVals, mode);
00586 leftOvers = rowCnt > 8 ? rowCnt % 8 : 0;
00587
00588
00589
00590
00591
00592
00593 if (leftOvers) {
00594 tempBuf[i].reset(new FixedBuffer[leftOvers * maxValueSize[i]]);
00595 count = leftOvers;
00596
00597 } else if (origRowCnt < 8) {
00598 tempBuf[i].reset(new FixedBuffer[origRowCnt * maxValueSize[i]]);
00599 count = origRowCnt;
00600 } else {
00601
00602 tempBuf[i].reset();
00603 }
00604
00605
00606 if (LCS_FIXED == mode || LCS_VARIABLE == mode) {
00607 hash[i].prepareFixedOrVariableBatch(
00608 (PBuffer) rowBlock[i], rowCnt);
00609 lcsBlockBuilder->putFixedVarBatch(
00610 i, (uint16_t *) rowBlock[i], tempBuf[i].get());
00611 if (mode == LCS_FIXED) {
00612 hash[i].clearFixedEntries();
00613 }
00614
00615 } else {
00616 uint16_t numVals;
00617
00618
00619 hash[i].prepareCompressedBatch(
00620 (PBuffer) rowBlock[i], rowCnt, (uint16_t *) &numVals, oVals);
00621 lcsBlockBuilder->putCompressedBatch(
00622 i, (PBuffer) rowBlock[i], tempBuf[i].get());
00623 }
00624
00625
00626 rowCnt = 0;
00627 hash[i].startNewBatch(!lastBatch ? count : 0);
00628 }
00629
00630
00631 if (!lastBatch) {
00632 lastRow -= count;
00633 }
00634 bool bStartNewBlock;
00635 bStartNewBlock = false;
00636
00637
00638
00639
00640
00641
00642 if (!lastBatch && origRowCnt < 8) {
00643
00644 for (i = 0; i < numColumns; i++) {
00645 lcsBlockBuilder->rollBackLastBatch(i, tempBuf[i].get());
00646 }
00647 bStartNewBlock = true;
00648 }
00649
00650
00651
00652
00653
00654 if (bStartNewBlock || (!lastBatch && lcsBlockBuilder->isEndOfBlock())) {
00655 writeBlock();
00656 startNewBlock();
00657 }
00658
00659
00660 if (!lastBatch) {
00661 for (i = 0; i < numColumns; i++) {
00662 rowCnt = 0;
00663 for (j = 0, val = tempBuf[i].get(); j < count; j++) {
00664 LcsHashValOrd vOrd;
00665 bool undoInsert = false;
00666
00667 hash[i].insert(val, &vOrd, &undoInsert);
00668
00669
00670
00671 assert(!undoInsert);
00672 addValueOrdinal(i, vOrd.getValOrd());
00673 rowCnt++;
00674 val += maxValueSize[i];
00675 }
00676 }
00677 }
00678
00679 for (i = 0; i < numColumns; i++) {
00680 if (tempBuf[i].get()) {
00681 tempBuf[i].reset();
00682 }
00683 }
00684 }
| void LcsClusterAppendExecStream::writeBlock | ( | | ) | [protected, inherited] | | ------------------------------------------- | - | | - | ------------------------ |
| bool LcsClusterAppendExecStream::getLastBlock | ( | PLcsClusterNode & | pBlock | ) | [protected, inherited] |
|---|
| void LcsClusterAppendExecStream::init | ( | | ) | [protected, inherited] | | ------------------------------------- | - | | - | ------------------------ |
Processes rows for loading.
Calls WriteBatch once values cannot fit into a page
Parameters:
Returns:
ExecStreamResult value
Definition at line 144 of file LcsClusterAppendExecStream.cpp.
References LcsClusterAppendExecStream::addValueOrdinal(), LcsClusterAppendExecStream::close(), LcsClusterAppendExecStream::clusterColsTupleData, EXECRC_BUF_OVERFLOW, EXECRC_EOS, EXECRC_QUANTUM_EXPIRED, EXECRC_YIELD, TupleAccessor::getCurrentByteCount(), LcsClusterAppendExecStream::getTupleForLoad(), LcsClusterAppendExecStream::hash, LcsClusterAppendExecStream::hashValOrd, LcsClusterAppendExecStream::isDone, LcsClusterAppendExecStream::isRowArrayFull(), LcsClusterAppendExecStream::lcsBlockBuilder, TupleAccessor::marshal(), ExecStreamQuantum::nTuplesMax, LcsClusterAppendExecStream::numColumns, LcsClusterAppendExecStream::outputTuple, LcsClusterAppendExecStream::outputTupleAccessor, LcsClusterAppendExecStream::outputTupleBuffer, LcsClusterAppendExecStream::postProcessTuple(), SingleOutputExecStream::pOutAccessor, LcsClusterAppendExecStream::rowCnt, LcsClusterAppendExecStream::writeBatch(), and LcsClusterAppendExecStream::writeBlock().
Referenced by LcsClusterAppendExecStream::execute().
Definition at line 31 of file LcsClusterAppendExecStream.cpp.
References SegPageLock::accessSegment(), LcsClusterAppendExecStream::blockSize, LcsClusterAppendExecStream::bufferLock, TupleData::compute(), LcsClusterAppendExecStream::initTupleLoadParams(), LcsClusterAppendExecStreamParams::inputProj, LcsClusterAppendExecStream::numRowCompressed, LcsClusterAppendExecStream::outputTuple, LcsClusterAppendExecStream::outputTupleAccessor, SingleInputExecStream::pInAccessor, SingleOutputExecStream::pOutAccessor, ConduitExecStream::prepare(), BTreeExecStream::prepare(), SegmentAccessor::pSegment, ExecStreamParams::scratchAccessor, LcsClusterAppendExecStream::scratchAccessor, BTreeDescriptor::segmentAccessor, LcsClusterAppendExecStream::startRow, LcsClusterAppendExecStream::tableColsTupleDesc, and BTreeExecStream::treeDescriptor.
Referenced by prepare().
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().
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().
| 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().
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(), BTreeSearchExecStream::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().
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().
| void LcsClusterAppendExecStream::closeImpl | ( | | ) | [virtual, inherited] | | ------------------------------------------ | - | | - | ---------------------- |
| SharedBTreeWriter BTreeExecStream::newWriter | ( | bool | monotonic = false | ) | [protected, inherited] |
|---|
| void BTreeExecStream::endSearch | ( | | ) | [protected, virtual, 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().
| 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] |
|---|
| bool ExecStream::canEarlyClose | ( | | ) | [virtual, inherited] | | ------------------------------ | - | | - | ---------------------- |
| 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 }
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().
| void ExecStream::setName | ( | std::string const & | | ) | [virtual, inherited] | | ------------------------ | - | ------------------- | | - | ---------------------- |
| std::string const & ExecStream::getName | ( | | ) | const [virtual, inherited] | | --------------------------------------- | - | | - | ---------------------------- |
| 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] | | --------------------------- | - | | - | ---------------------------- |
| bool ClosableObject::isClosed | ( | | ) | const [inline, inherited] | | ----------------------------- | - | | - | --------------------------- |
Returns:
whether the object has been closed
Definition at line 58 of file ClosableObject.h.
| void TraceSource::initTraceSource | ( | SharedTraceTarget | pTraceTarget, |
|---|---|---|---|
| std::string | name | ||
| ) | [virtual, inherited] |
| void TraceSource::trace | ( | TraceLevel | level, |
|---|---|---|---|
| std::string | message | ||
| ) | const [inherited] |
| bool TraceSource::isTracing | ( | | ) | const [inline, inherited] | | --------------------------- | - | | - | --------------------------- |
| bool TraceSource::isTracingLevel | ( | TraceLevel | level | ) | const [inline, inherited] |
|---|
| TraceTarget& TraceSource::getTraceTarget | ( | | ) | const [inline, inherited] | | ----------------------------------------------------------------- | - | | - | --------------------------- |
| std::string TraceSource::getTraceSourceName | ( | | ) | const [inline, inherited] | | ------------------------------------------- | - | | - | --------------------------- |
| 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] | | ------------------------------------------------------------------------------------------------------ | - | | - | --------------------------- |
| void TraceSource::disableTracing | ( | | ) | [inherited] | | -------------------------------- | - | | - | ------------- |
| void ErrorSource::initErrorSource | ( | SharedErrorTarget | pErrorTarget, |
|---|---|---|---|
| const std::string & | name | ||
| ) | [virtual, inherited] |
| void ErrorSource::postError | ( | ErrorLevel | level, |
|---|---|---|---|
| const std::string & | message, | ||
| void * | address, | ||
| long | capacity, | ||
| int | index | ||
| ) | [inherited] |
| bool ErrorSource::hasTarget | ( | | ) | const [inline, inherited] | | --------------------------- | - | | - | --------------------------- |
| ErrorTarget& ErrorSource::getErrorTarget | ( | | ) | const [inline, inherited] | | ----------------------------------------------------------------- | - | | - | --------------------------- |
Returns:
the SharedErrorTarget for this source
Definition at line 129 of file ErrorSource.h.
| 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] | | ------------------------------- | - | | - | ------------- |
| 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(), BTreeSearchExecStream::execute(), BTreeInsertExecStream::execute(), UncollectExecStream::execute(), SortedAggExecStream::execute(), ReshapeExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), BernoulliSamplingExecStream::execute(), and CalcExecStream::execute().
Member Data Documentation
Dynamic parameter id corresponding to the root pageId of the new cluster, if the pageId is required downstream.
Set to 0 if there's no need for the parameter.
Definition at line 61 of file LcsClusterReplaceExecStream.h.
Referenced by open(), and prepare().
Definition at line 113 of file BTreeExecStream.h.
Referenced by BTreeInsertExecStream::buildTree(), BTreeExecStream::closeImpl(), BTreeExecStream::copyParamsToDescriptor(), getTupleForLoad(), LcsClusterAppendExecStream::initLoad(), initTupleLoadParams(), BTreePrefetchSearchExecStream::innerSearchLoop(), BTreePrefetchSearchExecStream::newReader(), BTreeExecStream::newReader(), BTreeExecStream::newWriter(), open(), BTreeSearchExecStream::open(), BTreePrefetchSearchExecStream::open(), BTreeInsertExecStream::open(), BTreeExecStream::open(), prepare(), LcsClusterAppendExecStream::prepare(), LbmSearchExecStream::prepare(), LbmGeneratorExecStream::prepare(), BTreeSearchExecStream::prepare(), BTreeInsertExecStream::prepare(), BTreeExecStream::prepare(), and BTreeInsertExecStream::truncateTree().
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(), BTreeSearchExecStream::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().
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().
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(), open(), LbmUnionExecStream::open(), LbmSplicerExecStream::open(), LbmGeneratorExecStream::open(), LbmBitOpExecStream::open(), BTreeSearchExecStream::open(), BTreeInsertExecStream::open(), SegBufferWriterExecStream::open(), SegBufferReaderExecStream::open(), NestedLoopJoinExecStream::open(), CorrelationJoinExecStream::open(), ExecStream::prepare(), CalcExecStream::prepare(), NestedLoopJoinExecStream::processLeftInput(), LbmSearchExecStream::reachedTupleLimit(), ReshapeExecStream::readDynamicParams(), SegBufferWriterExecStream::readReaderRefCount(), BTreeSearchExecStream::readSearchKey(), BTreeSearchExecStream::readUpperBoundKey(), LbmSearchExecStream::setAdditionalKeys(), and LbmBitOpExecStream::writeStartRidParamValue().
Definition at line 51 of file SingleInputExecStream.h.
Referenced by SortedAggExecStream::compareGroupByKeys(), ExternalSortExecStreamImpl::computeFirstResult(), ExternalSortExecStreamImpl::execute(), LbmSplicerExecStream::execute(), FtrsTableWriterExecStream::execute(), BTreeSortExecStream::execute(), BTreeSearchUniqueExecStream::execute(), BTreeSearchExecStream::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(), getTupleForLoad(), LcsClusterAppendExecStream::getTupleForLoad(), LbmSplicerExecStream::getValidatedTuple(), initTupleLoadParams(), BTreeSearchExecStream::innerSearchLoop(), BTreePrefetchSearchExecStream::innerSearchLoop(), 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(), BTreeSearchExecStream::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(), BTreeSearchExecStream::readSearchKey(), LhxAggExecStream::setAggComputers(), LhxAggExecStream::setHashInfo(), SingleInputExecStream::setInputBufAccessors(), and JavaSinkExecStream::stuffByteBuffer().
The documentation for this class was generated from the following files:
- /home/pub/open/dev/fennel/lucidera/colstore/LcsClusterReplaceExecStream.h
- /home/pub/open/dev/fennel/lucidera/colstore/LcsClusterReplaceExecStream.cpp
Generated on Mon Jun 22 04:00:37 2009 for Fennel by 
1.5.1