LcsClusterDump Class Reference

Class used to dump the contents of a cluster page using fennel trace. More...

#include <LcsClusterDump.h>

Inheritance diagram for LcsClusterDump:

LcsClusterAccessBase TraceSource List of all members.

Public Member Functions

 LcsClusterDump (BTreeDescriptor const &bTreeDescriptor, TupleDescriptor const &colTupleDescInit, TraceLevel traceLevelInit, SharedTraceTarget pTraceTarget, std::string name)
void dump (uint64_t pageId, PConstLcsClusterNode pHdr, uint szBlock)
 Dumps out a cluster page.
uint getNumClusterCols ()
 Returns number of columns in cluster.
void setNumClusterCols (uint nCols)
 Sets number of columns in cluster.
void unlockClusterPage ()
 Unlocks cluster page.
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 ()

Protected Member Functions

LcsRid readRid ()
 Returns RID from btree tuple.
PageId readClusterPageId ()
 Returns cluster pageid from btree tuple.
void setHdrOffsets (PConstLcsClusterNode pHdr)
 Sets pointers to offset arrays in cluster page header.

Protected Attributes

TupleData bTreeTupleData
 Tuple data representing the btree key corresponding to the cluster page.
SegmentAccessor segmentAccessor
 Accessor for segment storing both btree and cluster pages.
ClusterPageLock clusterLock
 Buffer lock for the actual cluster node pages.
PageId clusterPageId
 Current cluster pageid.
LcsRid bTreeRid
 Current rid in btree used to access current cluster page.
uint nClusterCols
 Number of columns in cluster.
uint16_t * lastVal
 Offsets to the last value stored on the page for each column in cluster.
uint16_t * firstVal
 Offsets to the first value stored on the page for each column in cluster.
uint * nVal
 Number of distinct values in the page for each column in cluster.
uint16_t * delta
 For each column in the cluster, offset used to get the real offset within the page.

Private Member Functions

void callTrace (const char *format,...)
PBuffer fprintVal (uint idx, PBuffer pV, uint col)

Private Attributes

TraceLevel traceLevel
 The level at which tracing of cluster dump will be done.
TupleDescriptor colTupleDesc
 Tuple descriptor for the columns in a cluster page.

Detailed Description

Class used to dump the contents of a cluster page using fennel trace.

Definition at line 35 of file LcsClusterDump.h.

Constructor & Destructor Documentation

LcsClusterDump::LcsClusterDump ( BTreeDescriptor const &  bTreeDescriptor,
TupleDescriptor const &  colTupleDescInit,
TraceLevel  traceLevelInit,
SharedTraceTarget  pTraceTarget,
std::string  name 
) [explicit]

Definition at line 54 of file LcsClusterDump.cpp.

References colTupleDesc, and traceLevel.

00059                         :
00060         LcsClusterAccessBase(bTreeDescriptor),
00061         TraceSource(pTraceTargetInit, nameInit)
00062 {
00063     colTupleDesc = colTupleDescInit;
00064     traceLevel = traceLevelInit;
00065 }

Member Function Documentation

void LcsClusterDump::callTrace ( const char *  format,
  ... 
) [private]

Definition at line 229 of file LcsClusterDump.cpp.

References lnLen, and traceLevel.

Referenced by dump(), and fprintVal().

00230 {
00231     char buf[lnLen + 1];
00232     string str;
00233     va_list args;
00234 
00235     va_start(args, format);
00236     vsprintf(buf, format, args);
00237     va_end(args);
00238 
00239     str += buf;
00240     FENNEL_TRACE(traceLevel, str);
00241 }

PBuffer LcsClusterDump::fprintVal ( uint  idx,
PBuffer  pV,
uint  col 
) [private]

Definition at line 244 of file LcsClusterDump.cpp.

References callTrace(), colTupleDesc, UnalignedAttributeAccessor::getStoredByteCount(), lnByte, lnLen, lnValIdx, and nByte.

Referenced by dump().

00245 {
00246     uint j, sz, k, l;
00247     PBuffer p = pV;
00248     char st[lnLen + 1];
00249 
00250     st[lnLen] = 0;
00251     memset(st, ' ', lnLen);
00252     callTrace("%05u:", idx);
00253 
00254     UnalignedAttributeAccessor attrAccessor(colTupleDesc[col]);
00255     sz = attrAccessor.getStoredByteCount(p);
00256     l = sprintf(st + lnValIdx, "%4u: ", sz);
00257     st[lnValIdx + l] = 0;
00258 
00259     for (j = 0 ; j < sz; j++) {
00260         if (j && ((j % nByte) == 0)) {
00261             callTrace("%s", st);
00262             memset(st, ' ', lnLen);
00263         }
00264 
00265         k = oByte + lnByte * (j % nByte);
00266         l = sprintf(st + k, "%2X ", p[j]);
00267         st[k + l] = ' ';
00268         st[oStr + (j % nByte)] =  isprint(p[j]) ? p[j] : '.';
00269     }
00270 
00271     callTrace("%s", st);
00272 
00273     p += sz;
00274     return p;
00275 }

void LcsClusterDump::dump ( uint64_t  pageId,
PConstLcsClusterNode  pHdr,
uint  szBlock 
)

Dumps out a cluster page.

Parameters:
pageId pageid of the cluster page
pHdr pointer to the cluster page
szBlock number of bytes in the page

Definition at line 68 of file LcsClusterDump.cpp.

References bitVecPtr(), bitVecWidth(), calcWidth(), callTrace(), count(), LcsClusterAccessBase::delta, LcsClusterNode::firstRID, LcsClusterAccessBase::firstVal, fprintVal(), LcsClusterAccessBase::lastVal, LCS_COMPRESSED, LCS_FIXED, LCS_VARIABLE, lnLen, min(), LcsClusterNode::nBatch, LcsClusterAccessBase::nClusterCols, LcsClusterNode::nColumn, LcsBatchDir::nRow, LcsBatchDir::nVal, LcsClusterAccessBase::nVal, LcsClusterNode::oBatch, opaqueToInt(), LcsBatchDir::oVal, readBitVecs(), LcsBatchDir::recSize, and LcsClusterAccessBase::setHdrOffsets().

Referenced by LcsClusterAppendExecStreamTest::verifyClusterPages().

00070 {
00071     PBuffer pBlock = (PBuffer) pHdr;
00072     uint i, j, k;
00073     uint16_t *pO;
00074     PBuffer pR;
00075 
00076     uint count;
00077 
00078     uint nBits;
00079     PLcsBatchDir pBatch;
00080     WidthVec w;                     // bitVec width vector
00081     PtrVec p;                       // bitVec offsets
00082     uint iV;                        // number of bit vectors
00083     uint8_t *pBit;
00084     uint16_t v[MaxReadBatch];       // temporary space to store row indexes
00085     const char *mode;
00086 
00087     // set pointers for various offset arrays
00088 
00089     nClusterCols = pHdr->nColumn;
00090     setHdrOffsets(pHdr);
00091 
00092     // print header
00093 
00094     callTrace("Cluster Page Dump - PageId %ld", pageId);
00095     callTrace("-----------------------------");
00096     callTrace("Header");
00097     callTrace("------");
00098     callTrace("nColumn:          %5u", nClusterCols);
00099     callTrace("firstRid:         %5u", opaqueToInt(pHdr->firstRID));
00100     callTrace("oBatch:           %5u", pHdr->oBatch);
00101     callTrace("nBatch:           %5u", pHdr->nBatch);
00102     for (i = 0; i < nClusterCols; i++) {
00103         callTrace("lastVal[%d]:       %5u", i, lastVal[i]);
00104         callTrace("firstVal[%d]:      %5u", i, firstVal[i]);
00105         callTrace("nVal[%d]:          %5u", i, nVal[i]);
00106         callTrace("delta[%d]:         %5u", i, delta[i]);
00107     }
00108 
00109     callTrace("#############################################################");
00110 
00111     // print individual batch contents
00112 
00113     pBatch = (PLcsBatchDir) (pBlock + pHdr->oBatch);
00114     for (i = 0; i < pHdr->nBatch; i++) {
00115         // columns are stored in alternating batches.
00116         // Need to find out the offset to apply to column offsets.
00117         int col = i % nClusterCols;
00118         uint16_t deltaVal = delta[col];
00119 
00120         switch (pBatch[i].mode) {
00121         case LCS_COMPRESSED:
00122             mode = "Compressed";
00123             break;
00124         case LCS_VARIABLE:
00125             mode = "Variable";
00126             break;
00127         case LCS_FIXED:
00128             mode = "Fixed";
00129             break;
00130         default:
00131             permAssert(false);
00132         }
00133         callTrace("Batch #%2u (%s)", i + 1, mode);
00134         callTrace("--------------------");
00135         callTrace("mode:             %5u", pBatch[i].mode);
00136         callTrace("nRow:             %5u", pBatch[i].nRow);
00137         callTrace("nVal:             %5u", pBatch[i].nVal);
00138         callTrace("nValHighMark:     %5u", pBatch[i].nValHighMark);
00139         callTrace("oVal:             %5u", pBatch[i].oVal);
00140         callTrace("oLastValHighMark: %5u", pBatch[i].oLastValHighMark);
00141         callTrace("recSize:          %5u", pBatch[i].recSize);
00142 
00143         if (pBatch[i].mode == LCS_COMPRESSED) {
00144             nBits = calcWidth(pBatch[i].nVal);
00145 
00146             // calculate the bit vector widthes, sum(w[i]) is nBits
00147             iV = bitVecWidth(nBits, w);
00148 
00149             // this is where the bit vectors start
00150             pBit = pBlock + pBatch[i].oVal + pBatch[i].nVal * sizeof(uint16_t);
00151 
00152             // nBytes are taken by the bit vectors
00153             bitVecPtr(pBatch[i].nRow, iV, w, p, pBit);
00154 
00155             callTrace("Rows");
00156             callTrace("----");
00157 
00158             for (j = 0; j < pBatch[i].nRow;) {
00159                 char buf[lnLen + 1];
00160                 int bufidx = 0;
00161 
00162                 buf[0] = 0;
00163                 count = min(uint(pBatch[i].nRow - j), MaxReadBatch);
00164                 // read rows j to j+count -1
00165                 readBitVecs(v, iV, w, p, j, count);
00166 
00167                 for (k = 0; k < count; k++, j++) {
00168                     if ((j % 8) == 0) {
00169                         if (j > 0) {
00170                             callTrace("%s", buf);
00171                         }
00172                         sprintf(buf, "%5u: ", j);
00173                         bufidx = 7;
00174                     }
00175 
00176                     sprintf(buf + bufidx, "%5u ", (uint) v[k]);
00177                     bufidx += 6;
00178                 }
00179                 callTrace("%s", buf);
00180             }
00181 
00182             callTrace("Batch Values");
00183             callTrace("------------");
00184             pO = (uint16_t *) (pBlock + pBatch[i].oVal);
00185             for (j = 0; j < pBatch[i].nVal; j++) {
00186                 fprintVal(j, pBlock + pO[j] - deltaVal, col);
00187             }
00188 
00189         } else if (pBatch[i].mode == LCS_FIXED) {
00190             // fixed size rows
00191             callTrace("Fixed Size Rows");
00192             callTrace("---------------");
00193             pR = pBlock + pBatch[i].oVal;
00194             for (j = 0; j < pBatch[i].nRow; j++) {
00195                 fprintVal(j, pR, col);
00196                 pR += pBatch[i].recSize;
00197             }
00198         } else {
00199             // variable size rows
00200             callTrace("Variable Size Rows");
00201             callTrace("------------------");
00202             pO = (uint16_t *) (pBlock + pBatch[i].oVal);
00203             for (j = 0; j < pBatch[i].nRow; j++) {
00204                 fprintVal(j, pBlock + pO[j] - deltaVal, col);
00205             }
00206         }
00207         callTrace("#############################################################");
00208     }
00209 
00210     // print values, dereferencing them through the header values
00211 
00212     callTrace("Value List at the Bottom of the Page");
00213     callTrace("------------------------------------");
00214     for (i = 0; i < nClusterCols; i++) {
00215         callTrace("Column #%2u", i);
00216         callTrace("------------");
00217         if (lastVal[i] < szBlock) {
00218             pR = pBlock + lastVal[i];
00219             for (j = nVal[i]; j > 0; j--) {
00220                 pR = fprintVal(j, pR, i);
00221             }
00222         } else {
00223             callTrace("NONE.");
00224         }
00225     }
00226 }

LcsRid LcsClusterAccessBase::readRid (  )  [protected, inherited]

Returns RID from btree tuple.

Definition at line 37 of file LcsClusterAccessBase.cpp.

References LcsClusterAccessBase::bTreeTupleData.

Referenced by LcsClusterReader::getNextBTreeEntry(), LcsClusterReader::getNextPageForPrefetch(), LcsClusterReader::readClusterPage(), and LcsClusterReader::searchForRid().

00038 {
00039     return *reinterpret_cast<LcsRid const *> (bTreeTupleData[0].pData);
00040 }

PageId LcsClusterAccessBase::readClusterPageId (  )  [protected, inherited]

Returns cluster pageid from btree tuple.

Definition at line 42 of file LcsClusterAccessBase.cpp.

References LcsClusterAccessBase::bTreeTupleData.

Referenced by LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterReader::getNextBTreeEntry(), LcsClusterReader::getNextPageForPrefetch(), LcsClusterReader::position(), and LcsClusterReader::readClusterPage().

00043 {
00044     return *reinterpret_cast<PageId const *> (bTreeTupleData[1].pData);
00045 }

void LcsClusterAccessBase::setHdrOffsets ( PConstLcsClusterNode  pHdr  )  [protected, inherited]

Sets pointers to offset arrays in cluster page header.

Parameters:
pHdr pointer to cluster node header

Definition at line 47 of file LcsClusterAccessBase.cpp.

References LcsClusterAccessBase::delta, LcsClusterAccessBase::firstVal, LcsClusterAccessBase::lastVal, LcsClusterAccessBase::nClusterCols, and LcsClusterAccessBase::nVal.

Referenced by dump(), LcsClusterNodeWriter::init(), and LcsClusterReader::setUpBlock().

00048 {
00049     PBuffer p = (PBuffer) pHdr;
00050 
00051     lastVal = (uint16_t *) (p += sizeof(LcsClusterNode));
00052     firstVal = (uint16_t *) (p += sizeof(uint16_t) * nClusterCols);
00053     nVal = (uint *) (p += sizeof(uint16_t) * nClusterCols);
00054     delta = (uint16_t *) (p += sizeof(uint) * nClusterCols);
00055 }

uint LcsClusterAccessBase::getNumClusterCols (  )  [inline, inherited]

Returns number of columns in cluster.

Definition at line 118 of file LcsClusterAccessBase.h.

00119     {
00120         return nClusterCols;
00121     }

void LcsClusterAccessBase::setNumClusterCols ( uint  nCols  )  [inline, inherited]

Sets number of columns in cluster.

Definition at line 126 of file LcsClusterAccessBase.h.

00127     {
00128         nClusterCols = nCols;
00129     }

void LcsClusterAccessBase::unlockClusterPage (  )  [inherited]

Unlocks cluster page.

Definition at line 57 of file LcsClusterAccessBase.cpp.

References LcsClusterAccessBase::clusterLock, and SegPageLock::unlock().

Referenced by LcsClusterReader::close().

00058 {
00059     clusterLock.unlock();
00060 }

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 }

Member Data Documentation

TraceLevel LcsClusterDump::traceLevel [private]

The level at which tracing of cluster dump will be done.

I.e., the caller of this object can control the level at which dumps are generated.

Definition at line 43 of file LcsClusterDump.h.

Referenced by callTrace(), and LcsClusterDump().

TupleDescriptor LcsClusterDump::colTupleDesc [private]

Tuple descriptor for the columns in a cluster page.

Definition at line 48 of file LcsClusterDump.h.

Referenced by fprintVal(), and LcsClusterDump().

TupleData LcsClusterAccessBase::bTreeTupleData [protected, inherited]

Tuple data representing the btree key corresponding to the cluster page.

Definition at line 42 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterReader::getNextBTreeEntry(), LcsClusterReader::getNumRows(), LcsClusterAccessBase::LcsClusterAccessBase(), LcsClusterReader::readClusterPage(), LcsClusterAccessBase::readClusterPageId(), LcsClusterAccessBase::readRid(), and LcsClusterReader::searchForRid().

SegmentAccessor LcsClusterAccessBase::segmentAccessor [protected, inherited]

Accessor for segment storing both btree and cluster pages.

Definition at line 47 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterAccessBase::LcsClusterAccessBase(), and LcsClusterReader::position().

ClusterPageLock LcsClusterAccessBase::clusterLock [protected, inherited]

Buffer lock for the actual cluster node pages.

Shares the same segment as the btree corresponding to the cluster.

Definition at line 53 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterNodeWriter::close(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterAccessBase::LcsClusterAccessBase(), LcsClusterReader::moveToBlock(), LcsClusterReader::moveToBlockWithRid(), LcsClusterReader::readClusterPage(), and LcsClusterAccessBase::unlockClusterPage().

PageId LcsClusterAccessBase::clusterPageId [protected, inherited]

Current cluster pageid.

Definition at line 58 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterVerifier::getPageData(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterReader::moveToBlockWithRid(), and LcsClusterReader::readClusterPage().

LcsRid LcsClusterAccessBase::bTreeRid [protected, inherited]

Current rid in btree used to access current cluster page.

Definition at line 63 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::allocateClusterPage(), LcsClusterVerifier::getPageData(), and LcsClusterReader::readClusterPage().

uint LcsClusterAccessBase::nClusterCols [protected, inherited]

Number of columns in cluster.

Definition at line 68 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::addValue(), LcsClusterNodeWriter::allocArrays(), dump(), LcsClusterReader::getNumRows(), LcsClusterNodeWriter::init(), LcsClusterReader::initColumnReaders(), LcsClusterNodeWriter::LcsClusterNodeWriter(), LcsClusterNodeWriter::moveFromIndexToTemp(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterNodeWriter::openAppend(), LcsClusterNodeWriter::openNew(), LcsClusterReader::positionInBlock(), and LcsClusterAccessBase::setHdrOffsets().

uint16_t* LcsClusterAccessBase::lastVal [protected, inherited]

Offsets to the last value stored on the page for each column in cluster.

Definition at line 74 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::addValue(), dump(), LcsClusterNodeWriter::moveFromIndexToTemp(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterNodeWriter::openAppend(), LcsClusterNodeWriter::openNew(), LcsClusterNodeWriter::pickCompressionMode(), LcsClusterNodeWriter::putCompressedBatch(), LcsClusterNodeWriter::putFixedVarBatch(), LcsClusterNodeWriter::rollBackLastBatch(), LcsClusterAccessBase::setHdrOffsets(), and LcsClusterNodeWriter::undoValue().

uint16_t* LcsClusterAccessBase::firstVal [protected, inherited]

Offsets to the first value stored on the page for each column in cluster.

Points to the end of the firstVal, so subtracting lastVal from firstVal will tell you the number of bytes taken up by values for a column, since lastVals are appended in front of firstVal

Definition at line 82 of file LcsClusterAccessBase.h.

Referenced by dump(), LcsClusterNodeWriter::moveFromIndexToTemp(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterNodeWriter::openNew(), and LcsClusterAccessBase::setHdrOffsets().

uint* LcsClusterAccessBase::nVal [protected, inherited]

Number of distinct values in the page for each column in cluster.

Definition at line 87 of file LcsClusterAccessBase.h.

Referenced by LcsClusterNodeWriter::addValue(), dump(), LcsClusterNodeWriter::moveFromIndexToTemp(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterNodeWriter::openAppend(), LcsClusterNodeWriter::openNew(), LcsClusterNodeWriter::pickCompressionMode(), LcsClusterNodeWriter::putCompressedBatch(), LcsClusterNodeWriter::putFixedVarBatch(), LcsClusterNodeWriter::rollBackLastBatch(), LcsClusterAccessBase::setHdrOffsets(), and LcsClusterNodeWriter::undoValue().

uint16_t* LcsClusterAccessBase::delta [protected, inherited]

For each column in the cluster, offset used to get the real offset within the page.

Definition at line 93 of file LcsClusterAccessBase.h.

Referenced by dump(), LcsClusterNodeWriter::moveFromTempToIndex(), LcsClusterNodeWriter::openNew(), LcsClusterAccessBase::setHdrOffsets(), and LcsColumnReader::sync().

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