RegisterReference.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/calculator/RegisterReference.h#3 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2004-2009 SQLstream, Inc.
// Copyright (C) 2009-2009 LucidEra, Inc.
//
// 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
//
// RegisterReference
//
*/
#ifndef Fennel_RegisterReference_Included
#define Fennel_RegisterReference_Included

#include "fennel/tuple/TupleData.h"
#include "fennel/tuple/StandardTypeDescriptor.h"
#include "fennel/exec/DynamicParam.h"
#include "boost/lexical_cast.hpp"

#include <strstream>

FENNEL_BEGIN_NAMESPACE

using namespace std;
using boost::lexical_cast;

class Calculator;
class RegisterSetBinding;

typedef RegisterSetBinding ** TRegisterSetP;
typedef TupleDescriptor ** TRegisterSetDescP;
typedef uint32_t TRegisterRefProp;


class FENNEL_CALCULATOR_EXPORT RegisterSetBinding
{
    const bool ownTheBase;              // we own (and will delete) the base
    uint ncols;
    TupleData *const base;              // the underlying data
    PConstBuffer *datumAddr;            // we allocate
    // In this set, the nth register is bound to TupleDatum d = (*base)[n].
    // Its length is d.cbLen, its location is d.pDatum.
    // However, d.pDatum = 0 indicates a null value.
    // At bind time, the datum location for the nth register is copied to
    // datumAddr[n]; saving this address lets the calculator overwrite a null
    // value. Changing the register value via the TupleDatum directly changes
    // base.

public:
    ~RegisterSetBinding();

    RegisterSetBinding(TupleData* base, bool ownIt = false);

    RegisterSetBinding(
        TupleData* base,
        const TupleData* shadow,
        bool ownIt = false);

    const TupleData& asTupleData() const {
        return *base;
    }

    TupleDatum& operator[](int n) {
        assert((n >= 0) && (n < ncols));
        return (*base)[n];
    }

    PConstBuffer getTargetAddr(int n) {
        assert((n >= 0) && (n < ncols));
        return datumAddr[n];
    }
};


class FENNEL_CALCULATOR_EXPORT RegisterReference
{
public:
    enum ERegisterSet {
        EFirstSet = 0,
        ELiteral =  0,
        EInput =    1,
        EOutput =   2,
        ELocal =    3,
        EStatus =   4,
        ELastSet,           
        EUnknown =  1000
    };

    explicit
    RegisterReference()
        : mSetIndex(EUnknown),
          mIndex(0),
          mType(STANDARD_TYPE_END_NO_UNICODE),
          mPData(0),
          mCbData(0),
          mCbStorage(0),
          mPDynamicParamManager(0)
    {
        mProp = EPropNone;
    }

    explicit
    RegisterReference(
        ERegisterSet set,
        unsigned long index,
        StandardTypeDescriptorOrdinal datatype)
        : mSetIndex(set),
          mIndex(index),
          mType(datatype),
          mPData(0),
          mCbData(0),
          mCbStorage(0),
          mPDynamicParamManager(0)
    {
        assert(mSetIndex < ELastSet);
        assert(mSetIndex >= EFirstSet);
        setDefaultProperties();
    }

    virtual
    ~RegisterReference() {}


    enum EProperties {
        EPropNone         = 0,  
        EPropReadOnly     = 1,  

        EPropCachePointer = 2,  

        EPropPtrReset     = 4,  
        EPropByRefOnly    = 8   


    };

    // TODO: Replace with array indexed by ERegisterSet
    static const uint32_t KLiteralSetDefault =
        EPropReadOnly | EPropCachePointer;

    static const uint32_t KInputSetDefault   = EPropReadOnly;

    static const uint32_t KOutputSetDefault  = EPropNone;

    static const uint32_t KLocalSetDefault   =
        EPropCachePointer | EPropPtrReset;

    static const uint32_t KStatusSetDefault  = EPropNone;

    void setCalc(Calculator* calcP);

    void cachePointer();

    ERegisterSet setIndex() const
    {
        return mSetIndex;
    }
    unsigned long index() const
    {
        return mIndex;
    }
    bool isValid() const
    {
        return ((mSetIndex < ELastSet) ? true : false);
    }
    StandardTypeDescriptorOrdinal type() const {
        return mType;
    }

    static inline string getSetName(ERegisterSet set)
    {
        switch (set) {
        case ELiteral:
            return "C";
        case ELocal:
            return "L";
        case EInput:
            return "I";
        case EOutput:
            return "O";
        case EStatus:
            return "S";
        default:
            throw std::invalid_argument(
                "fennel/calculator/RegisterReference::getSetName");
        }
    }


    static inline string toString(ERegisterSet set, unsigned long index)
    {
        ostringstream ostr("");
        ostr << getSetName(set) << index;
        return ostr.str();
    }

    string toString() const;
    virtual string valueToString() const = 0;
    virtual bool isNull() const = 0;

    inline DynamicParamManager* getDynamicParamManager() const {
        assert(mPDynamicParamManager);
        return mPDynamicParamManager;
    }

    TupleDatum* getBinding(bool resetFromNull = false) const {
        // validate indexes
        assert(mRegisterSetP);
        assert(mSetIndex < ELastSet);
        assert(mRegisterSetP[mSetIndex]);
        RegisterSetBinding* rsb = mRegisterSetP[mSetIndex];
        TupleDatum& bind = (*rsb)[mIndex];
        if (resetFromNull) {
            if (!bind.pData) {
                bind.pData = mRegisterSetP[mSetIndex]->getTargetAddr(mIndex);
            }
        }
        return &bind;
    }

protected:
    const ERegisterSet mSetIndex;

    const unsigned long mIndex;

    const StandardTypeDescriptorOrdinal mType;

    TRegisterSetP mRegisterSetP;

    TRegisterSetDescP mRegisterSetDescP;

    vector<RegisterReference *>*mResetP;

    bool mCachePtrModified;

    PBuffer mPData;

    TupleStorageByteLength mCbData;

    TupleStorageByteLength mCbStorage;

    TRegisterRefProp mProp;

    DynamicParamManager* mPDynamicParamManager;

    void setDefaultProperties();

};

template<typename TMPLT>
class RegisterRef : public RegisterReference
{
public:
    explicit
    RegisterRef () : RegisterReference()
    {}

    explicit
    RegisterRef(
        ERegisterSet set,
        unsigned long index,
        StandardTypeDescriptorOrdinal datatype)
        : RegisterReference(set, index, datatype)
    {}

    TMPLT value() const {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            assert(mPData);
            return *(reinterpret_cast<TMPLT*>(mPData));
        } else {
            TupleDatum *bind = getBinding();
            assert(bind->pData); // Cannot read from a NULL value.
            return *(reinterpret_cast<TMPLT*>(
                const_cast<PBuffer>(bind->pData)));
        }
    }


    void
    value(TMPLT newV)
    {
        // JDF 06/19/06 Need to find out why output register used for
        // histogram support gets marked as ReadOnly.
        if (0) {
            assert(!(mProp & EPropReadOnly));
        }

        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            assert(mPData);
            *(reinterpret_cast<TMPLT*>(mPData)) = newV;
        } else {
            TupleDatum *bind = getBinding(true); // reset when null
            assert(bind->pData);
            *(reinterpret_cast<TMPLT*>(
                const_cast<PBuffer>(bind->pData))) = newV;
        }
    }

    bool isNullable()
    {
        return !(mProp & EPropReadOnly);
    }

    void toNull() {
        assert(!(mProp & EPropReadOnly));
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            if ((mProp & EPropPtrReset) && !mCachePtrModified) {
                mCachePtrModified = true;
                mResetP->push_back(this);
            }
            mPData = NULL;
            mCbData = 0;
        } else {
            TupleDatum *bind = getBinding();
            bind->pData = NULL;
        }
    }

    bool isNull() const {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            return (mPData ? false : true);
        } else {
            TupleDatum *bind = getBinding();
            return (bind->pData ? false : true);
        }
    }

    TMPLT
    pointer() const {
        assert(StandardTypeDescriptor::isArray(mType));
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            assert(mPData);  // useful or harmful?
            return reinterpret_cast<TMPLT>(mPData);
        } else {
            TupleDatum *bind = getBinding();
            assert(bind->pData);
            return reinterpret_cast<TMPLT>(const_cast<PBuffer>(bind->pData));
        }
    }
    void
    pointer(TMPLT newP, TupleStorageByteLength len)
    {
        assert(!(mProp & EPropReadOnly));
        assert(newP);  // use toNull()
        assert(StandardTypeDescriptor::isArray(mType));
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            if ((mProp & EPropPtrReset) && !mCachePtrModified) {
                mCachePtrModified = true;
                mResetP->push_back(this);
            }
            mPData = reinterpret_cast<PBuffer>(newP);
            mCbData = len;
        } else {
            TupleDatum *bind = getBinding();
            bind->pData = reinterpret_cast<PConstBuffer>(newP);
            bind->cbData = len;
        }
    }
    TMPLT*
    refer() const {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            return reinterpret_cast<TMPLT*>(const_cast<PBuffer>(mPData));
        } else {
            TupleDatum *bind = getBinding();
            return reinterpret_cast<TMPLT*>(const_cast<PBuffer>(bind->pData));
        }
    }
    void
    refer(RegisterRef<TMPLT>* from)
    {
        assert(!(mProp & (EPropCachePointer | EPropPtrReset)));
        TupleDatum *bind = getBinding();
        bind->pData = reinterpret_cast<PConstBuffer>(
            const_cast<TMPLT*>(from->refer()));
        bind->cbData = from->length();
    }

    TupleStorageByteLength
    length() const
    {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            return mCbData;
        } else {
            TupleDatum *bind = getBinding();
            return bind->cbData;
        }
    }
    TupleStorageByteLength
    storage() const
    {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            return mCbStorage;
        } else {
            assert(mRegisterSetP);
            assert(mSetIndex < ELastSet);
            assert(mRegisterSetDescP[mSetIndex]);
            //Next 3 lines clarify complex 4th line:
            //TupleDescriptor* tupleDescP = mRegisterSetDescP[mSetIndex];
            //TupleAttributeDescriptor* attrP = &((*tupleDescP)[mIndex]);
            //return attrP->cbStorage;
            return ((*(mRegisterSetDescP[mSetIndex]))[mIndex]).cbStorage;
        }
    }
    TupleStorageByteLength
    stringLength() const
    {
        assert(StandardTypeDescriptor::isArray(mType));
        if (StandardTypeDescriptor::isVariableLenArray(mType)) {
            return length();
        } else {
            return storage();
        }
    }
    void
    length(TupleStorageByteLength newLen)
    {
        if (mProp & (EPropCachePointer | EPropPtrReset)) {
            // useful or harmful?
            assert(newLen == 0 ? true : (mPData == 0 ? false : true));
            // useful or harmful?
            assert(newLen <= mCbStorage);
            mCbData = newLen;
        } else {
            assert(
                newLen
                <= ((*(mRegisterSetDescP[mSetIndex]))[mIndex]).cbStorage);
            TupleDatum *bind = getBinding();
            bind->cbData = newLen;
        }
    }
    void
    stringLength(TupleStorageByteLength newLen)
    {
        assert(StandardTypeDescriptor::isArray(mType));
        if (StandardTypeDescriptor::isVariableLenArray(mType)) {
            length(newLen);
        }
    }

    string
    valueToString() const {
        if (this->isNull()) { // does assert checking for us
            return "NULL";
        }
        if (StandardTypeDescriptor::isArray(mType)) {
#if 0
            // Does not compile due to ptr/non-ptr compile issue
            // TODO: Make this work with VARBINARY and I18N
            // TODO: Remove the reinterpret_cast. Ugly.
            string ret((char *)(this->pointer()), this->getS());
            return ret;
#endif
            return "Unimpl";
        } else {
            // TODO: Remove boost call, use stream instead
            return boost::lexical_cast<std::string>(this->value());
        }
    }
protected:

};

FENNEL_END_NAMESPACE

#endif

// End RegisterReference.h

---