LcsHash Class Reference

LcsHash class is used by LcsclusterAppendExecStream. More...

#include <LcsHash.h>

List of all members.

Public Member Functions
	LcsHash ()
	~LcsHash ()
void	init (PBuffer hashBlockInit, SharedLcsClusterNodeWriter clusterBlockWriterInit, TupleDescriptor const &colTupleDescInit, uint columnIdInit, uint blockSizeInit)
	Initializes the LcsHash object.
void	insert (TupleDatum &colTupleDatum, LcsHashValOrd *valOrd, bool *undoInsert)
	Inserts a single column tuple into the hash table.
void	insert (PBuffer dataWithLen, LcsHashValOrd *valOrd, bool *undoInsert)
	Inserts a data buffer of a column into the hash table.
void	undoInsert (TupleDatum &colTupleDatum)
	Undoes the previous insert of a column tuple.
void	undoInsert (PBuffer dataWithLen)
	Undoes the previous insert of a column data buffer.
void	prepareFixedOrVariableBatch (uint8_t *rowArray, uint numRows)
	Prepares a fixed or variable batch to be written to the cluster block.
void	prepareCompressedBatch (uint8_t *rowArray, uint numRows, uint16_t *numVals, uint16_t *offsetIndexVector)
	Prepares a compressed batch to be written to the cluster block.
void	clearFixedEntries ()
	Clears the fixed values from batch to indicate the offset is not longer useful because the key storage can be relocated between batches.
void	startNewBatch (uint leftOvers)
	Prepares LcsHash object for a new batch.
void	restore (uint numVals, uint16_t lastValOff)
	Sets up hash with values from an existing cluster block.
uint	getMaxValueSize ()
	Gets the maximum value length.
bool	isHashFull (uint leftOvers=0)
	Checks if the hash table is full.
Private Member Functions
uint	computeKey (PBuffer dataWithLen)
	Compue hash key from value.
bool	search (uint key, PBuffer dataWithLen, LcsHashValOrd *valOrd, LcsHashValueNode **v)
	Search for ordinal using hash key and column data value.
Private Attributes
uint	columnId
	column for which this LcsHash structure is built.
LcsHashTable	hash
	LcsHashTable object contains logic to fit the data strcture into one block as well as logic to manage the hash entries and hash value nodes in the hash table.
SharedLcsClusterNodeWriter	clusterBlockWriter
	Block writer object used to add new value to a cluster block.
TupleDescriptor	colTupleDesc
	The column tuple descriptor.
TupleDataWithBuffer	colTuple
	The column currently begin compressed.
UnalignedAttributeAccessor	attrAccessor
	Attribute accessor of the column.
TupleDataWithBuffer	searchTuple
	The column being compared against.
boost::scoped_array< FixedBuffer >	colTupleBuffer
	Scratch memory to store the current column value being compressed.
uint16_t	valCnt
	Number of unique values in the current batch.
uint	maxValueSize
	Largest value size in the current batch.
LcsUndoType	undo
	Structure containing info for undoing the most recent hash insert.
uint8_t *	magicTable
	Hash seed values.
uint	numChecks
	Hash table statistics: number of hash key checks.
uint	numMatches
	Hash table statistics: number of hash key matches.
SharedLcsCompareColKeyUsingOffsetIndex	compareInst
	Helper class to LcsCompare.

---

Detailed Description

LcsHash class is used by LcsclusterAppendExecStream.

LcsClusterAppendExecStream splits up the columns in a cluster and passes column tuples(consisting of only one column) to LcsHash, which tranforms the tuple and sends to the LcsClusterNodeWriter data pointers with encoded length information.

Definition at line 447 of file LcsHash.h.

---

Constructor & Destructor Documentation

LcsHash::LcsHash

(

)

[explicit]

Definition at line 61 of file LcsHash.cpp.

References columnId, MagicTable, magicTable, maxValueSize, numChecks, numMatches, and valCnt.

{
    columnId                = 0;
    valCnt                  = 0;
    maxValueSize            = 0;
    magicTable              = MagicTable;
    numMatches              = 0;
    numChecks               = 0;
}

LcsHash::~LcsHash

(

)

[inline]

Definition at line 559 of file LcsHash.h.

    {
    }

---

Member Function Documentation

uint LcsHash::computeKey

(

PBuffer

dataWithLen

)

[private]

Compue hash key from value.

Parameters:

[in]

dataWithLen

pointer to buffer with value and length info encoded at the first 1 or 2 bytes.

Returns:

hash key

Definition at line 510 of file LcsHash.cpp.

References attrAccessor, UnalignedAttributeAccessor::getStoredByteCount(), hash, magicTable, and LcsHashTable::numHashEntries().

Referenced by insert(), and restore().

{
    uint8_t  keyVal[2] = {0,0}, oldKeyVal[2]={0,17};
    uint     i, colSize = attrAccessor.getStoredByteCount(dataWithLen);

    /*
     * Compute the hash key over all the bytes, inlcuding the length
     * bytes. This saves the implicit memcpy in loadValue.
     */
    for (i = 0;
         i < colSize;
         oldKeyVal[0] = keyVal[0], oldKeyVal[1] = keyVal[1], i++, dataWithLen++)
    {
        keyVal[0] = magicTable[oldKeyVal[0] ^ *dataWithLen];
        keyVal[1] = magicTable[oldKeyVal[1] ^ *dataWithLen];
    }

    return ((keyVal[1]<<8) + keyVal[0]) % hash.numHashEntries();
}

bool LcsHash::search	(	uint	key,
		PBuffer	dataWithLen,
		LcsHashValOrd *	valOrd,
		LcsHashValueNode **	v
	)			[private]

Search for ordinal using hash key and column data value.

Parameters:

[in]	key	hash key to locate
[in]	dataWithLen	pointer to data buffer with length info encoded
[out]	valOrd	hash value node ordinal number
[out]	v	hash value node if value is previously inserted

Returns:

true if a match in both the key and the data value is found

Definition at line 295 of file LcsHash.cpp.

References attrAccessor, clusterBlockWriter, colTuple, colTupleDesc, columnId, TupleDescriptor::compareTuples(), LcsHashTable::getFirstValueNode(), LcsHashTable::getNextValueNode(), hash, UnalignedAttributeAccessor::loadValue(), numChecks, numMatches, TupleDataWithBuffer::resetBuffer(), searchTuple, LcsHashValueNode::valueOffset, and LcsHashValueNode::valueOrd.

Referenced by insert(), and restore().

{
    LcsHashValueNode       *valueNode;
    bool    compareRes;

    attrAccessor.loadValue(colTuple[0], dataWithLen);

    for (valueNode = hash.getFirstValueNode(key);
         valueNode != NULL;
         valueNode = hash.getNextValueNode(valueNode))
     {
        numChecks++;

        /*
         * Skips invalid hash entries.
         * Entries were invalidated by clearFixedEntries.
         */
        if (valueNode->valueOffset == 0) {
            continue;
        }

        attrAccessor.loadValue(
            searchTuple[0],
            clusterBlockWriter->getOffsetPtr(columnId, valueNode->valueOffset));

        compareRes = colTupleDesc.compareTuples(colTuple, searchTuple);

        /*
         * Prepare for next loadValue.
         */
        searchTuple.resetBuffer();

        if (compareRes == 0) {
            numMatches++;
            *valOrd = valueNode->valueOrd;
            if (vNode) {
                *vNode = valueNode;
            }
            colTuple.resetBuffer();
            return true;
        }
    }

    colTuple.resetBuffer();
    /*
     * No Match.
     */
    return false;
}

void LcsHash::init	(	PBuffer	hashBlockInit,
		SharedLcsClusterNodeWriter	clusterBlockWriterInit,
		TupleDescriptor const &	colTupleDescInit,
		uint	columnIdInit,
		uint	blockSizeInit
	)

Initializes the LcsHash object.

Parameters:

[in]	hashBlockInit	block to hold the hash table
[in]	clusterBlockWriterInit	reference to the node writer
[in]	colTupleDescInit	tuple descriptor for the column tuple
[in]	columnIdInit	column ID for which this LcsHash is compressing.
[in]	blockSizeInit	block size

Definition at line 71 of file LcsHash.cpp.

References attrAccessor, clusterBlockWriter, colTuple, colTupleBuffer, colTupleDesc, columnId, compareInst, UnalignedAttributeAccessor::compute(), TupleDataWithBuffer::computeAndAllocate(), FixedBuffer, UnalignedAttributeAccessor::getMaxByteCount(), hash, LcsHashTable::init(), maxValueSize, searchTuple, and valCnt.

{
    /*
     * clears and sets up hash block
     */
    memset(hashBlockInit,0,blockSizeInit);
    hash.init(hashBlockInit,  blockSizeInit);

    columnId                = columnIdInit;
    valCnt                  = 0;
    maxValueSize            = 0;
    clusterBlockWriter      = clusterBlockWriterInit;

    assert(colTupleDescInit.size() == 1);
    colTupleDesc            = colTupleDescInit;
    attrAccessor.compute(colTupleDesc[0]);

    /*
     * Temporary in-memory representation for the tuple this LcsHash
     * is working on.
     */
    colTuple.computeAndAllocate(colTupleDesc);
    searchTuple.computeAndAllocate(colTupleDesc);

    /*
     * colTupleBuffer provides storage for storing the length as well the data
     * buffer in a compat format described in TupleData.h. The length could take
     * up to 2 bytes.
     */
    colTupleBuffer.reset(
        new FixedBuffer[attrAccessor.getMaxByteCount()]);

    compareInst = SharedLcsCompareColKeyUsingOffsetIndex(
        new LcsCompareColKeyUsingOffsetIndex(
            clusterBlockWriter, &hash, colTupleDesc, columnId, attrAccessor));
}

void LcsHash::insert	(	TupleDatum &	colTupleDatum,
		LcsHashValOrd *	valOrd,
		bool *	undoInsert
	)

Inserts a single column tuple into the hash table.

It also causes the column value to be inserted into the cluster block if needed.

Parameters:

[in]	colTupleDatum	column tuple to insert
[out]	valOrd	hash value node ordinal
[out]	undoInsert	true if this insert should be undone

Definition at line 113 of file LcsHash.cpp.

References attrAccessor, colTupleBuffer, and UnalignedAttributeAccessor::storeValue().

{
    /*
     * gets the data buffer with length encoded
     */
    PBuffer dataWithLen = colTupleBuffer.get();
    attrAccessor.storeValue(colTupleDatum, dataWithLen);

    insert(dataWithLen, valOrd, undoInsert);
}

void LcsHash::insert	(	PBuffer	dataWithLen,
		LcsHashValOrd *	valOrd,
		bool *	undoInsert
	)

Inserts a data buffer of a column into the hash table.

It also causes the column value to be inserted into the cluster block if needed.

Parameters:

[in]	dataWithLen	data buffer of column tuple to insert
[out]	valOrd	hash value node ordinal
[out]	undoInsert	true if this insert should be undone

Definition at line 128 of file LcsHash.cpp.

References attrAccessor, clusterBlockWriter, columnId, computeKey(), LcsHashTable::getNewValueNode(), UnalignedAttributeAccessor::getStoredByteCount(), hash, LcsHashTable::insertNewValueNode(), LcsHashTable::isFull(), LcsHashValOrd::isValueInBatch(), maxValueSize, NEWBATCHVALUE, NEWENTRY, NOTHING, search(), LcsUndoType::set(), LcsHashValOrd::setValueInBatch(), undo, valCnt, LcsHashValueNode::valueOffset, and LcsHashValueNode::valueOrd.

{
    uint        key;
    uint16_t    newValueOffset;
    LcsHashValueNode *vPtr = 0;
    TupleStorageByteLength storageLength;

    /*
     * Compression mode could change dynamically so we have to check everytime.
     * If this batch will not be compressed, then there is no reason to
     * generate a real hash code.  Hash code generation is expensive, so
     * try to avoid it.
     */
    bool noCompress = clusterBlockWriter->noCompressMode(columnId);
    key = noCompress ? 0 : computeKey(dataWithLen);

    *undoInsert     = false;

    /*
     * If value is not in hash, or
     * if we are not in compress mode
     * (in which case we allow duplicates in the hash table),
     * then adds value to the hash.
     */
    if (noCompress || !search(key, dataWithLen, valOrd, &vPtr)) {
        LcsHashValueNode       *newNode;

        /*
         * If hash table is full,  or
         * if the cluster page is full
         * then returns and indicates the need to undo the insert.
         */
        *undoInsert =
            hash.isFull() ||
            !clusterBlockWriter->addValue(
                columnId, dataWithLen, &newValueOffset);

        if (*undoInsert) {
            /*
             * Prepares undo action.
             */
            undo.set(NOTHING, key, maxValueSize, 0);
            return;
        }

        /*
         * Inserts a new node only when the above call does not return
         * undoInsert.  If a new node is inserted but the undoInsert above is
         * true, the subsequent undoInsert() call will not roll back the new
         * node correctly if undo.what is not set to NEWENTRY(the default value
         * is NOTHING).
         */
        newNode = hash.getNewValueNode();
        newNode->valueOffset = newValueOffset;
        *valOrd = valCnt ++;
        valOrd->setValueInBatch();
        newNode->valueOrd = *valOrd;

        hash.insertNewValueNode(key, newNode);

        /*
         * Prepares undo action.
         */
        undo.set(NEWENTRY, key, maxValueSize, 0);

        storageLength = attrAccessor.getStoredByteCount(dataWithLen);

        if (storageLength > maxValueSize) {
            maxValueSize = storageLength;
        }
    } else {
        /*
         * We found the value in the hash (from the Search() call above),
         * so it is already in the block,
         * but it still may not be part of the current batch.
         * Whether it is or not, call addValue(), so that we can adjust
         * space left in the block.
         */
        bool bFirstTimeInBatch = !valOrd->isValueInBatch();

        *undoInsert =
            !clusterBlockWriter->addValue(columnId, bFirstTimeInBatch);

        if (*undoInsert) {
            /*
             * Prepares undo action.
             */
            undo.set(NOTHING, key, maxValueSize, 0);
            return;
        }

        (vPtr->valueOrd).setValueInBatch();
        *valOrd = vPtr->valueOrd;

        /*
         * Prepares undo action.
         */
        if (bFirstTimeInBatch) {
            undo.set(NEWBATCHVALUE, key, maxValueSize, vPtr);
        } else {
            undo.set(NOTHING, key, maxValueSize, 0);
        }
    }
    /*
     * Otherwise the value is already in the hash, and the current batch
     * already has a pointer to that value, so don't do anything.
     */
}

void LcsHash::undoInsert

(

TupleDatum &

colTupleDatum

)

Undoes the previous insert of a column tuple.

This will be called if we are trying to add all of the columns in a cluster and at least one can't fit we will remove previously added cluster column values.

Parameters:

[in]

colTupleDatum

column tuple just inserted

Definition at line 240 of file LcsHash.cpp.

References attrAccessor, colTupleBuffer, and UnalignedAttributeAccessor::storeValue().

{
    /*
     * gets the data buffer with length encoded
     */
    PBuffer dataWithLen = colTupleBuffer.get();
    attrAccessor.storeValue(colTupleDatum, dataWithLen);

    undoInsert(dataWithLen);

}

void LcsHash::undoInsert

(

PBuffer

dataWithLen

)

Undoes the previous insert of a column data buffer.

Parameters:

[in]

dataWithLen

data buffer to column tuple just inserted

Definition at line 252 of file LcsHash.cpp.

References clusterBlockWriter, columnId, hash, LcsUndoType::key, maxValueSize, NEWBATCHVALUE, NEWENTRY, NOTHING, LcsUndoType::origMaxValueSize, LcsUndoType::reset(), undo, LcsHashTable::undoNewValueNode(), valCnt, LcsHashValueNode::valueOrd, LcsUndoType::vPtr, and LcsUndoType::what.

{
    switch (undo.what) {
    case NOTHING:
        {
            /*
             * Value already existed in the batch.
             */
            clusterBlockWriter->undoValue(columnId, NULL, false);
            break;
        }
    case NEWENTRY:
        {
            /*
             * First time in block.
             *
             * To remove the a new value entry
             * 1) decrements the total count,
             * 2) resets location where next value entry will gox
             * 3) removes entry from hash
             * 4) resets maximum value size
             * 5) removes value from block
             */
            valCnt--;
            hash.undoNewValueNode(undo.key);
            maxValueSize = undo.origMaxValueSize;
            clusterBlockWriter->undoValue(columnId, dataWithLen, true);
            break;
        }
    case NEWBATCHVALUE:
        {
            /*
             * Already in block but first time in batch.
             * Need to remove value from batch
             */
            clusterBlockWriter->undoValue(columnId, NULL, true);
            (&undo.vPtr->valueOrd)->clearValueInBatch();
            break;
        }
    }
    undo.reset();
}

void LcsHash::prepareFixedOrVariableBatch	(	uint8_t *	rowArray,
		uint	numRows
	)

Prepares a fixed or variable batch to be written to the cluster block.

Parameters:

[in,out]	rowArray	upon input, this array holds value node ordinals; at output, the array holds offsets for values in a batch
[in]	numRows	number of values in a batch

Definition at line 407 of file LcsHash.cpp.

References hash, and LcsHashTable::valueNodes.

{
    uint            i;
    uint16_t        *rowWORDArray=(uint16_t*)rowArray;
    LcsHashValueNode       *pValueNodes;

    pValueNodes = hash.valueNodes;

    /*
     * Stores the offset to the column values in rowWORDArray
     */
    for (i = 0; i < numRows; i++) {
        rowWORDArray[i] = pValueNodes[rowWORDArray[i]].valueOffset;
    }
}

void LcsHash::prepareCompressedBatch	(	uint8_t *	rowArray,
		uint	numRows,
		uint16_t *	numVals,
		uint16_t *	offsetIndexVector
	)

Prepares a compressed batch to be written to the cluster block.

Parameters:

[in,out]	rowArray	upon input, this array holds value nodes ordinals; at output, it holds the indices to the offset array of the column value stored on a cluster block.
[in]	numRows	number of values in a batch
[in]	numVals	(out) number of distinct values in a batch
[out]	offsetIndexVector	at output, it holds the offsets of the column value stored on a cluster block.

Definition at line 350 of file LcsHash.cpp.

References compareInst, hash, LcsHashValueNode::sortedOrd, valCnt, LcsHashTable::valueNodes, LcsHashValueNode::valueOffset, and LcsHashValueNode::valueOrd.

{
    uint16_t    i;
    uint16_t    *rowWORDArray=(uint16_t*)rowArray;
    *numVals        = 0;

    /*
     * Puts all value ordinals in batch in Vals array.
     */
    for (i = 0; i < valCnt; i++) {
        if ((hash.valueNodes[i].valueOrd).isValueInBatch()) {
            hash.valueNodes[i].sortedOrd = *numVals;
            offsetIndexVector[(*numVals)++] = i;
        }
    }

    /*
     * Sorts the value ordinals based on the key values.
     */
    std::sort(
        offsetIndexVector,
        offsetIndexVector + (*numVals),
        LcsCompare(compareInst));

    /*
     * Now OffsetIndexVector is sorted. Sets sortedOrd, which is basically index
     * into the OffsetIndexVector, in valueNodes array.
     */
    for (i = 0; i < *numVals; i++) {
        hash.valueNodes[offsetIndexVector[i]].sortedOrd = i;
    }

    /*
     * Having stored the sortedOrd away, replaces value Ordinals in
     * OffsetIndexVector array with offset from the valueNodes array. Now
     * OffsetIndexVector will contain offsets sorted based on the values they
     * point to.
     */
    for (i = 0; i < *numVals; i++) {
        offsetIndexVector[i] =
            hash.valueNodes[offsetIndexVector[i]].valueOffset;
    }

    /*
     * Stores the index to OffsetIndexVector in the Row array. Now the
     * rowWORDArray contains indices to the OffsetIndexVector,  which conains
     * offsets sorted based on the column values they point to.
     */
    for (i = 0; i < numRows; i++) {
        rowWORDArray[i] = hash.valueNodes[rowWORDArray[i]].sortedOrd;
    }
}

void LcsHash::clearFixedEntries

(

)

Clears the fixed values from batch to indicate the offset is not longer useful because the key storage can be relocated between batches.

Definition at line 426 of file LcsHash.cpp.

References clusterBlockWriter, columnId, hash, valCnt, LcsHashTable::valueNodes, LcsHashValueNode::valueOffset, and LcsHashValueNode::valueOrd.

{
    /*
     * Only clears entries if the next batch is not guaranteed to be fixed mode.
     */
    if (!clusterBlockWriter->noCompressMode(columnId)) {
        for (uint i = 0; i < valCnt; i++) {
            if ((hash.valueNodes[i].valueOrd).isValueInBatch()) {
                hash.valueNodes[i].valueOffset = 0;
            }
        }
    }
}

void LcsHash::startNewBatch

(

uint

leftOvers

)

Prepares LcsHash object for a new batch.

Parameters:

[in]

leftOvers

number of left over hash value nodes from the previous batch. The new batch needs to leave room apriori for these nodes.

Definition at line 488 of file LcsHash.cpp.

References clusterBlockWriter, columnId, hash, LcsHashTable::isFull(), maxValueSize, LcsHashTable::resetBatch(), LcsHashTable::resetHash(), and valCnt.

{
    /*
     * If the hash is full we need to start over. Otherwise just clear the
     * entries used in building th eprevious batch.
     */
    if (clusterBlockWriter->noCompressMode(columnId) ||
        hash.isFull(leftOvers))
    {
        hash.resetHash();
        valCnt       = 0;
        maxValueSize = 0;
    } else {
        hash.resetBatch();
    }
}

void LcsHash::restore	(	uint	numVals,
		uint16_t	lastValOff
	)

Sets up hash with values from an existing cluster block.

This is called when appending to an existing block.

Parameters:

[in]	numVals	number of values for this column
[in]	lastValOff	offset of the last value stored for this column

Definition at line 440 of file LcsHash.cpp.

References attrAccessor, clusterBlockWriter, columnId, computeKey(), dummy(), LcsHashTable::getNewValueNode(), UnalignedAttributeAccessor::getStoredByteCount(), hash, LcsHashTable::insertNewValueNode(), LcsHashTable::isFull(), maxValueSize, search(), valCnt, LcsHashValueNode::valueOffset, and LcsHashValueNode::valueOrd.

{
    uint            i;
    uint            key;
    PBuffer         dataWithLen;
    LcsHashValueNode      *newNode;
    LcsHashValOrd   dummy;
    LcsHashValOrd   valOrd;
    TupleStorageByteLength storageLength;

    /*
     * Compression mode could change dynamically so we have to check everytime.
     * If this batch will not be compressed, then there is no reason to
     * generate a real hash code.  Hash code generation is expensive, so
     * try to avoid it.
     */
    bool noCompress = clusterBlockWriter->noCompressMode(columnId);

    for (i = 0; i < numVals && !(hash.isFull()); i++) {
        dataWithLen = clusterBlockWriter->getOffsetPtr(columnId,lastValOff);
        key = noCompress ? 0 : computeKey(dataWithLen);

        /*
         * If value is not in hash, or if we are not in compress mode (in which
         * case we allow duplicates in the hash table), then adds value to the
         * hash.
         */
        if (noCompress || !search(key, dataWithLen, &dummy)) {
            newNode = hash.getNewValueNode();

            valOrd = valCnt++;
            newNode->valueOrd = valOrd;
            newNode->valueOffset = (uint16_t) lastValOff;

            hash.insertNewValueNode(key,  newNode);

            storageLength = attrAccessor.getStoredByteCount(dataWithLen);
            if (storageLength > maxValueSize) {
                maxValueSize = storageLength;
            }
        }

        lastValOff = clusterBlockWriter->getNextVal(
            columnId,
            (uint16_t)lastValOff);
    }
}

uint LcsHash::getMaxValueSize

(

)

[inline]

Gets the maximum value length.

Returns:

data value length, including the bytes encoding the length information.

Definition at line 893 of file LcsHash.h.

References maxValueSize.

{
    return maxValueSize;
}

bool LcsHash::isHashFull

(

uint

leftOvers = 0

)

[inline]

Checks if the hash table is full.

Parameters:

[in]

leftOvers

number of left over hash value nodes from the previous batch. The next batch need to leave room apriori for these nodes.

Returns:

true if hash table is full

Definition at line 898 of file LcsHash.h.

References hash, and LcsHashTable::isFull().

{
    return hash.isFull(leftOvers);
}

---

Member Data Documentation

uint LcsHash::columnId [private]

column for which this LcsHash structure is built.

Definition at line 454 of file LcsHash.h.

Referenced by clearFixedEntries(), init(), insert(), LcsHash(), restore(), search(), startNewBatch(), and undoInsert().

LcsHashTable LcsHash::hash [private]

LcsHashTable object contains logic to fit the data strcture into one block as well as logic to manage the hash entries and hash value nodes in the hash table.

Definition at line 461 of file LcsHash.h.

Referenced by clearFixedEntries(), computeKey(), init(), insert(), isHashFull(), prepareCompressedBatch(), prepareFixedOrVariableBatch(), restore(), search(), startNewBatch(), and undoInsert().

SharedLcsClusterNodeWriter LcsHash::clusterBlockWriter [private]

Block writer object used to add new value to a cluster block.

Definition at line 466 of file LcsHash.h.

Referenced by clearFixedEntries(), init(), insert(), restore(), search(), startNewBatch(), and undoInsert().

TupleDescriptor LcsHash::colTupleDesc [private]

The column tuple descriptor.

Definition at line 471 of file LcsHash.h.

Referenced by init(), and search().

TupleDataWithBuffer LcsHash::colTuple [private]

The column currently begin compressed.

Definition at line 476 of file LcsHash.h.

Referenced by init(), and search().

UnalignedAttributeAccessor LcsHash::attrAccessor [private]

Attribute accessor of the column.

Definition at line 481 of file LcsHash.h.

Referenced by computeKey(), init(), insert(), restore(), search(), and undoInsert().

TupleDataWithBuffer LcsHash::searchTuple [private]

The column being compared against.

Definition at line 486 of file LcsHash.h.

Referenced by init(), and search().

boost::scoped_array<FixedBuffer> LcsHash::colTupleBuffer [private]

Scratch memory to store the current column value being compressed.

Definition at line 491 of file LcsHash.h.

Referenced by init(), insert(), and undoInsert().

uint16_t LcsHash::valCnt [private]

Number of unique values in the current batch.

The type of this field should be the same as that of LcsHashValOrd.

Definition at line 497 of file LcsHash.h.

Referenced by clearFixedEntries(), init(), insert(), LcsHash(), prepareCompressedBatch(), restore(), startNewBatch(), and undoInsert().

uint LcsHash::maxValueSize [private]

Largest value size in the current batch.

The size includes the bytes encoding the length information.

Definition at line 503 of file LcsHash.h.

Referenced by getMaxValueSize(), init(), insert(), LcsHash(), restore(), startNewBatch(), and undoInsert().

LcsUndoType LcsHash::undo [private]

Structure containing info for undoing the most recent hash insert.

Definition at line 508 of file LcsHash.h.

Referenced by insert(), and undoInsert().

uint8_t* LcsHash::magicTable [private]

Hash seed values.

Definition at line 513 of file LcsHash.h.

Referenced by computeKey(), and LcsHash().

uint LcsHash::numChecks [private]

Hash table statistics: number of hash key checks.

Definition at line 518 of file LcsHash.h.

Referenced by LcsHash(), and search().

uint LcsHash::numMatches [private]

Hash table statistics: number of hash key matches.

Definition at line 523 of file LcsHash.h.

Referenced by LcsHash(), and search().

SharedLcsCompareColKeyUsingOffsetIndex LcsHash::compareInst [private]

Helper class to LcsCompare.

It stores the comparison context.

Definition at line 528 of file LcsHash.h.

Referenced by init(), and prepareCompressedBatch().

---

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

• /home/pub/open/dev/fennel/lucidera/colstore/LcsHash.h
• /home/pub/open/dev/fennel/lucidera/colstore/LcsHash.cpp

---