LbmEntry.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/lucidera/bitmap/LbmEntry.h#25 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Copyright (C) 2005-2009 The Eigenbase Project
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_LbmEntry_Included
#define Fennel_LbmEntry_Included

#include "fennel/tuple/TupleData.h"
#include "fennel/tuple/TupleDescriptor.h"
#include "fennel/tuple/TupleAccessor.h"
#include "fennel/lucidera/bitmap/LbmSegment.h"
#include <algorithm>

using namespace std;

FENNEL_BEGIN_NAMESPACE

class FENNEL_LBM_EXPORT LbmEntry
    : public LbmSegment
{
    PBuffer scratchBuffer;

    PBuffer mergeScratchBuffer;

    uint scratchBufferSize;

    uint scratchBufferUsableSize;

    TupleData entryTuple;

    TupleDescriptor keyDesc;

    LcsRid currSegByteStartRID;

    uint currentEntrySize;

    uint keySize;

    uint bitmapSegSize;

    uint maxSegSize;

    PBuffer currSegDescByte;

    PBuffer currSegByte;
    uint currSegLength;

    inline bool isSingleton() const;

    inline bool isSingleBitmap() const;

    inline void setRIDSegByte(PBuffer pSegByte, LcsRid rid);

    inline void setRIDCurrentSegByte(LcsRid rid);

    bool setRIDAdjacentSegByte(LcsRid rid);

    bool setRIDNewSegment(LcsRid rid);

    inline void resetSegment();

    bool openNewSegment(LcsRid rid);

    void openLastSegment();

    void closeCurrentSegment();

    bool closeCurrentSegment(LcsRid rid);

    inline bool isSegmentOpen();

    /*
     * Get the last segment descriptor and calculate the number of rows
     * contained in the current entry, by going through
     * the segement descriptors from the start to the end.
     *
     * @param [out] lastSegDescByte the last SegDesc byte in this entry
     *
     * @param [out] lastZeroRIDs number of RIDs from rows not having this
     *  key value.
     *
     * @return number of rows encoded by this entry.
     */
    uint getRowCount(PBuffer &lastSegDescByte, uint &lastZeroRIDs);

    static uint getCompressedRowCount(
        PBuffer pDescStart, PBuffer pDescEnd,
        PBuffer &lastSegDescByte, uint &lastZeroRIDs);

    bool growEntry(LcsRid rid, uint reserveSpace);

    bool adjustEntry(TupleData &inputTuple);

    bool addSegDesc(uint reservedSpace, uint bitmapLength);

    bool singleton2Bitmap();

    bool spliceSingleton(TupleData &inputTuple);

    void copyToMergeBuffer(
        TupleData &newEntry, LcsRid startRid, PBuffer segStart,
        PBuffer segDescStart);

    bool addNewSegment(
        TupleData &inputTuple, LcsRid prevSrid, PBuffer prevSegDesc,
        PBuffer nextSegDesc, PBuffer prevSeg, uint prevSegBytes,
        uint prevZeroBytes);

    bool addNewMiddleSegment(
        TupleData &inputTuple, LcsRid prevSrid, PBuffer prevSegDesc,
        PBuffer nextSegDesc, PBuffer prevSeg, uint prevSegBytes,
        uint prevZeroBytes);

    bool addNewAdjacentSegment(
        TupleData &inputTuple, LcsRid prevSrid, PBuffer prevSegDesc,
        PBuffer nextSegDesc, PBuffer prevSeg, uint prevSegBytes,
        uint prevZeroBytes);

    bool setZeroLength(
        uint nZeroBytes, PBuffer pLenDesc, uint &lengthBytes);

    void addNewRid(
        PBuffer nextSegDesc, PBuffer newSeg, LcsRid newRid,
        uint remainingSegLen);

    void splitEntry(TupleData &inputTuple);

    void mergeIntoSplitEntry(
        TupleData &inputTuple, TupleData &splitEntry);

    int segmentContainsRid(
        LcsRid rid,
        LcsRid startRid,
        PBuffer pSeg,
        uint nSegBytes);

    uint getMergeSpaceRequired(TupleData const &inputTuple);

    void validateEntrySize();

    static const uint LbmMinEntryPerPage = 8;

    static const uint LbmSmallSingleBitmap = 256;

    inline static bool isSingleBitmap(TupleData const &inputTuple);

    static string toBitmapString(TupleData const &inputTuple);

    static string dumpSeg(PBuffer segDesc, PBuffer segDescEnd, PBuffer seg);

    static string dumpBitmap(PBuffer seg, uint segBytes);

    static string printDatum(
        TupleDatum const &tupleDatum,
        bool reverseByteOrder);

    static string printByte(uint8_t byte);

    static string toRIDString(TupleData const &inputTuple);

    static string dumpSegRID(
        PBuffer segDesc, PBuffer segDescEnd, PBuffer seg,
        string prefix, LcsRid srid);

    static string dumpBitmapRID(
        PBuffer seg, uint segBytes,
        string prefix, LcsRid srid);

    static void generateSegRIDs(
        PBuffer segDesc, PBuffer segDescEnd, PBuffer seg,
        vector<LcsRid> &ridValues, LcsRid srid);

    static void generateBitmapRIDs(
        PBuffer seg, uint segBytes, vector<LcsRid> &ridValues,
        LcsRid srid);

public:

    explicit LbmEntry();

    ~LbmEntry() {}

    void init(
        PBuffer scratchBufferInit, PBuffer mergeScratchBufferInit,
        uint scratchBufferSizeInit, TupleDescriptor const &tupleDesc);

    void setEntryTuple(TupleData const &entryTuple);

    bool setRID(LcsRid rid);

    int compareEntry(
        TupleData const &inputTuple,
        TupleDescriptor const &tupleDesc) const;

    bool mergeEntry(TupleData &inputTuple);

    TupleData const &produceEntryTuple();

    string toString();

    uint getRowCount();

    static uint getRowCount(TupleData const &inputTuple);

    bool containsRid(LcsRid rid);

    bool inRange(LcsRid rid);

    static string toString(TupleData const &inputTuple, bool printRID = false);

    static void getSizeBounds(
        TupleDescriptor const &indexTupleDesc, uint pageSize,
        uint &minEntrySize, uint &maxEntrySize);

    static void generateRIDs(
        TupleData const &inputTuple, vector<LcsRid> &ridValues);

    static uint getScratchBufferSize(uint bitmapColSize);

    static uint getMaxBitmapSize(uint bitmapColSize);

    inline static bool isSingleton(TupleData const &inputTuple);

    inline static LcsRid getStartRid(
        TupleData const &tuple);
};


/**************************************************
  Definitions of inline methods for class LbmEntry
 **************************************************/

inline bool LbmEntry::isSingleton(TupleData const &inputTuple)
{
    return (inputTuple[inputTuple.size() - 2].isNull() &&
        inputTuple[inputTuple.size() - 1].isNull());
}

inline LcsRid LbmEntry::getStartRid(
    TupleData const &tuple)
{
    return *reinterpret_cast<LcsRid const *> (tuple[tuple.size()-3].pData);
}

inline bool LbmEntry::isSingleton() const
{
    return (pSegStart == pSegEnd);
}


inline bool LbmEntry::isSingleBitmap(TupleData const &inputTuple)
{
    return (inputTuple[inputTuple.size() - 2].isNull() &&
        !inputTuple[inputTuple.size() - 1].isNull());
}


inline bool LbmEntry::isSingleBitmap() const
{
    return (pSegDescStart == NULL);
}

inline void LbmEntry::setRIDSegByte(PBuffer pSegByte, LcsRid rid)
{
    assert(pSegByte);
    *pSegByte |= (uint8_t)(1 << (opaqueToInt(rid) % LbmOneByteSize));
}

inline void LbmEntry::setRIDCurrentSegByte(LcsRid rid)
{
    setRIDSegByte(currSegByte, rid);
}

inline bool LbmEntry::isSegmentOpen()
{
    return (currSegDescByte != NULL);
}

inline void LbmEntry::resetSegment()
{
    currSegByte = NULL;
    currSegLength = 0;
    currSegByteStartRID = (LcsRid)0;
    currSegDescByte = NULL;
}

FENNEL_END_NAMESPACE

#endif

// End LbmEntry.h

---