LcsClusterNodeWriter.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/lucidera/colstore/LcsClusterNodeWriter.h#18 $
// 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_LcsClusterNodeWriter_Included
#define Fennel_LcsClusterNodeWriter_Included

#include "fennel/lucidera/colstore/LcsClusterAccessBase.h"
#include "fennel/lucidera/colstore/LcsBitOps.h"
#include "fennel/lucidera/colstore/LcsClusterDump.h"
#include "fennel/btree/BTreeWriter.h"
#include "fennel/tuple/TupleData.h"
#include "fennel/tuple/UnalignedAttributeAccessor.h"
#include <boost/scoped_array.hpp>

FENNEL_BEGIN_NAMESPACE

const int LcsMaxRollBack = 8;
const int LcsMaxLeftOver = 7;
const int LcsMaxSzLeftError = 4;

enum ForceMode { none = 0, fixed = 1, variable = 2 };

class FENNEL_LCS_EXPORT LcsClusterNodeWriter
    : public LcsClusterAccessBase, public TraceSource
{
private:
    SharedBTreeWriter bTreeWriter;

    SegmentAccessor scratchAccessor;

    ClusterPageLock bufferLock;

    PLcsClusterNode pHdr;

    uint hdrSize;

    PBuffer pIndexBlock;

    PBuffer *pBlock;

    uint szBlock;

    int minSzLeft;

    boost::scoped_array<LcsBatchDir> batchDirs;

    boost::scoped_array<PBuffer> pValBank;

    boost::scoped_array<uint16_t> oValBank;

    boost::scoped_array<uint16_t> valBankStart;

    boost::scoped_array<uint16_t> batchOffset;

    boost::scoped_array<uint> batchCount;

    int szLeft;

    boost::scoped_array<uint> nBits;

    boost::scoped_array<uint> nextWidthChange;

    bool arraysAllocated;

    boost::scoped_array<ForceMode> bForceMode;

    boost::scoped_array<uint> forceModeCount;

    boost::scoped_array<uint> maxValueSize;

    boost::scoped_array<UnalignedAttributeAccessor> attrAccessors;

    SharedLcsClusterDump clusterDump;

    TupleDescriptor colTupleDesc;

    PBuffer valueSource(
        uint16_t lastValOffset, PBuffer pValBank, uint16_t oValBank,
        PBuffer pBlock, uint16_t f)
    {
        // if value not in back use
        if (f < lastValOffset) {
            return pValBank + f - oValBank;
        } else {
            return pBlock + f;
        }
    }

    RecordNum moveFromIndexToTemp();

    void moveFromTempToIndex();

    void allocArrays();

    inline uint32_t round8Boundary(uint32_t val)
    {
        return val & 0xfffffff8;
    }

    inline uint32_t roundIf8Boundary(uint32_t val)
    {
        if (val > 8) {
            return round8Boundary(val);
        }
    }

public:
    explicit LcsClusterNodeWriter(
        BTreeDescriptor const &treeDescriptorInit,
        SegmentAccessor const &accessorInit,
        TupleDescriptor const &colTupleDescInit,
        SharedTraceTarget pTraceTargetInit,
        std::string nameInit);

    ~LcsClusterNodeWriter();

    bool getLastClusterPageForWrite(PLcsClusterNode &pBlock, LcsRid &firstRid);

    PLcsClusterNode allocateClusterPage(LcsRid firstRid);

    void init(uint nColumns, PBuffer indexBlock, PBuffer *pBlock, uint szBlock);

    void close();

    void openNew(LcsRid startRID);

    bool openAppend(
        uint *nValOffsets, uint16_t *lastValOffsets, RecordNum &nrows);

    void describeLastBatch(uint column, uint &dRow, uint &recSize);

    uint16_t getNextVal(uint column, uint16_t thisVal);

    void rollBackLastBatch(uint column, PBuffer pVal);

    inline bool noCompressMode(uint column) const
    {
        return bForceMode[column] == fixed ||
                bForceMode[column] == variable;
    };

    inline PBuffer getOffsetPtr(uint column, uint16_t offset)
    {
        return pBlock[column] + offset;
    };

    bool addValue(uint column, bool bFirstTimeInBatch);

    bool addValue(uint column, PBuffer pVal, uint16_t *oVal);

    void undoValue(uint column, PBuffer pVal, bool bFirstInBatch);

    void putCompressedBatch(uint column, PBuffer pRows, PBuffer pBuf);

    void putFixedVarBatch(uint column, uint16_t *pRows, PBuffer pBuf);

    void pickCompressionMode(
        uint column, uint fixedSize, uint nRows,
        uint16_t **pValOffset,
        LcsBatchMode &compressionMode);

    bool isEndOfBlock()
    {
        uint col;
        int valueSizeNeeded;

        for (valueSizeNeeded = 0, col = 0; col < nClusterCols; col++) {
            valueSizeNeeded += batchDirs[col].recSize * LcsMaxLeftOver;
        }

        return szLeft <= (minSzLeft + valueSizeNeeded);
    }

    void endBlock()
    {
        moveFromTempToIndex();
    }
};

FENNEL_END_NAMESPACE

#endif

// End LcsClusterNodeWriter.h

---