|| || || || || || || ||

---

TableTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_TableTem_h
#define Impala_Core_Table_TableTem_h

#include <vector>
#include <iostream>
#include "Util/DatabaseReadString.h"
#include "Util/DatabaseWriteString.h"
#include "Util/IOBuffer.h"
#include "Core/Table/Table.h"
#include "Core/Column/ColumnTem.h"
#include "Core/Column/InvalidColumn.h"

namespace Impala
{
namespace Core
{
namespace Table
{


template<class Col1T,
         class Col2T = Column::InvalidColumn,
         class Col3T = Column::InvalidColumn,
         class Col4T = Column::InvalidColumn,
         class Col5T = Column::InvalidColumn,
         class Col6T = Column::InvalidColumn,
         class Col7T = Column::InvalidColumn,
         class Col8T = Column::InvalidColumn,
         class Col9T = Column::InvalidColumn>
class TableTem : public Table
{
public:
    typedef Column::InvalidColumn InvalidColumn;

    typedef typename Col1T::ColElemType Col1ElemType;
    typedef typename Col2T::ColElemType Col2ElemType;
    typedef typename Col3T::ColElemType Col3ElemType;
    typedef typename Col4T::ColElemType Col4ElemType;
    typedef typename Col5T::ColElemType Col5ElemType;
    typedef typename Col6T::ColElemType Col6ElemType;
    typedef typename Col7T::ColElemType Col7ElemType;
    typedef typename Col8T::ColElemType Col8ElemType;
    typedef typename Col9T::ColElemType Col9ElemType;

    TableTem(int size) : mCol1(size), mCol2(size), mCol3(size), mCol4(size),
                         mCol5(size), mCol6(size), mCol7(size), mCol8(size),
                         mCol9(size), mColNames(9)
    {
    }

    TableTem(const Col1T& c1,
             const Col2T& c2 = InvalidColumn(),
             const Col3T& c3 = InvalidColumn(),
             const Col4T& c4 = InvalidColumn(),
             const Col5T& c5 = InvalidColumn(),
             const Col6T& c6 = InvalidColumn(),
             const Col7T& c7 = InvalidColumn(),
             const Col8T& c8 = InvalidColumn(),
             const Col9T& c9 = InvalidColumn())
        : mCol1(c1), mCol2(c2), mCol3(c3), mCol4(c4), mCol5(c5), mCol6(c6),
          mCol7(c7), mCol8(c8), mCol9(c9), mColNames(9), mInfo("no info")
    {
    }

    virtual
    ~TableTem()
    {
    }

    void
    SetInfo(String info)
    {
        mInfo = info;
    }

    String
    GetInfo() const
    {
        return mInfo;
    }

    // col range : 1-9
    void
    SetColName(int col, String name)
    {
        mColNames[col-1] = name;
    }

    // col range : 1-9
    String
    GetColName(int col) const
    {
        return mColNames[col-1];
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    ReadColNames(String fileName, Util::Database* db)
    {
        mColNames.clear();
        Util::DatabaseReadString(std::back_inserter(mColNames), 
                                 fileName, db, false, 9);
    }

    void
    ReadColNames(Util::IOBuffer* buffer)
    {
        mColNames.clear();
        Util::DatabaseReadString(std::back_inserter(mColNames), 
                                 buffer, false, 9);
    }

    bool
    WriteColNames(String fileName, Util::Database* db)
    {
        return Util::DatabaseWriteString(fileName, db, mColNames.begin(),
                                         mColNames.end(), 9);
    }

    bool
    WriteColNames(Util::IOBuffer* buffer)
    {
        return Util::DatabaseWriteString(buffer, mColNames.begin(),
                                         mColNames.end(), 9);
    }
#else // REPOSITORY_USED

    void
    ReadColNames(Util::IOBuffer* buffer)
    {
        mColNames.clear();
        if (buffer)
            buffer->ReadStrings(std::back_inserter(mColNames), false, 9);
    }

    bool
    WriteColNames(Util::IOBuffer* buffer)
    {
        if (buffer)
            return buffer->WriteStrings(mColNames.begin(), mColNames.end(), 9);
    }
#endif // REPOSITORY_USED

    int
    Capacity() const
    {
        return mCol1.Capacity();
    }

    bool
    Reserve(int newCapacity, bool copyData)
    {
        if (newCapacity == Capacity())
            return true;
        if (mCol1.Valid() && (!mCol1.Reserve(newCapacity, copyData)))
            return false;
        if (mCol2.Valid() && (!mCol2.Reserve(newCapacity, copyData)))
            return false;
        if (mCol3.Valid() && (!mCol3.Reserve(newCapacity, copyData)))
            return false;
        if (mCol4.Valid() && (!mCol4.Reserve(newCapacity, copyData)))
            return false;
        if (mCol5.Valid() && (!mCol5.Reserve(newCapacity, copyData)))
            return false;
        if (mCol6.Valid() && (!mCol6.Reserve(newCapacity, copyData)))
            return false;
        if (mCol7.Valid() && (!mCol7.Reserve(newCapacity, copyData)))
            return false;
        if (mCol8.Valid() && (!mCol8.Reserve(newCapacity, copyData)))
            return false;
        if (mCol9.Valid() && (!mCol9.Reserve(newCapacity, copyData)))
            return false;
        if (mLast > newCapacity)
            mLast = newCapacity;
        return true;
    }

    bool
    ReserveMin(int minimalCapacity, bool copyData)
    {
        if (minimalCapacity <= Capacity())
            return true;
        return Reserve(minimalCapacity, copyData);
    }

    Col1ElemType
    Get1(int index) const
    {
        return mCol1.Get(index);
    }

    Col2ElemType
    Get2(int index) const
    {
        return mCol2.Get(index);
    }

    Col3ElemType
    Get3(int index) const
    {
        return mCol3.Get(index);
    }

    Col4ElemType
    Get4(int index) const
    {
        return mCol4.Get(index);
    }

    Col5ElemType
    Get5(int index) const
    {
        return mCol5.Get(index);
    }

    Col6ElemType
    Get6(int index) const
    {
        return mCol6.Get(index);
    }

    Col7ElemType
    Get7(int index) const
    {
        return mCol7.Get(index);
    }

    Col8ElemType
    Get8(int index) const
    {
        return mCol8.Get(index);
    }

    Col9ElemType
    Get9(int index) const
    {
        return mCol9.Get(index);
    }

    void
    Set1(int index, Col1ElemType value)
    {
        return mCol1.Set(index, value);
    }

    void
    Set2(int index, Col2ElemType value) 
    {
        return mCol2.Set(index, value);
    }

    void
    Set3(int index, Col3ElemType value) 
    {
        return mCol3.Set(index, value);
    }

    void
    Set4(int index, Col4ElemType value) 
    {
        return mCol4.Set(index, value);
    }

    void
    Set5(int index, Col5ElemType value) 
    {
        return mCol5.Set(index, value);
    }

    void
    Set6(int index, Col6ElemType value) 
    {
        return mCol6.Set(index, value);
    }

    void
    Set7(int index, Col7ElemType value) 
    {
        return mCol7.Set(index, value);
    }

    void
    Set8(int index, Col8ElemType value) 
    {
        return mCol8.Set(index, value);
    }

    void
    Set9(int index, Col9ElemType value) 
    {
        return mCol9.Set(index, value);
    }

    bool
    Add(Col1ElemType e1)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4,
        Col5ElemType e5)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mCol5.Set(mLast, e5);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4,
        Col5ElemType e5, Col6ElemType e6)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mCol5.Set(mLast, e5);
        mCol6.Set(mLast, e6);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4,
        Col5ElemType e5, Col6ElemType e6, Col7ElemType e7)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mCol5.Set(mLast, e5);
        mCol6.Set(mLast, e6);
        mCol7.Set(mLast, e7);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4,
        Col5ElemType e5, Col6ElemType e6, Col7ElemType e7, Col8ElemType e8)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mCol5.Set(mLast, e5);
        mCol6.Set(mLast, e6);
        mCol7.Set(mLast, e7);
        mCol8.Set(mLast, e8);
        mLast++;
        return true;
    }

    bool
    Add(Col1ElemType e1, Col2ElemType e2, Col3ElemType e3, Col4ElemType e4,
        Col5ElemType e5, Col6ElemType e6, Col7ElemType e7, Col8ElemType e8,
        Col9ElemType e9)
    {
        if (mLast == Capacity())
            if (!Reserve(Impala::Max(2*Capacity(),1), true))
                return false;
        mCol1.Set(mLast, e1);
        mCol2.Set(mLast, e2);
        mCol3.Set(mLast, e3);
        mCol4.Set(mLast, e4);
        mCol5.Set(mLast, e5);
        mCol6.Set(mLast, e6);
        mCol7.Set(mLast, e7);
        mCol8.Set(mLast, e8);
        mCol9.Set(mLast, e9);
        mLast++;
        return true;
    }

    // cursor part

    Col1ElemType
    Get1AtCursor()
    {
        return mCol1[mCursor];
    }

    Col2ElemType
    Get2AtCursor()
    {
        return mCol2[mCursor];
    }

    Col3ElemType
    Get3AtCursor()
    {
        return mCol3[mCursor];
    }

    Col4ElemType
    Get4AtCursor()
    {
        return mCol4[mCursor];
    }

    Col5ElemType
    Get5AtCursor()
    {
        return mCol5[mCursor];
    }

    Col6ElemType
    Get6AtCursor()
    {
        return mCol6[mCursor];
    }

    Col7ElemType
    Get7AtCursor()
    {
        return mCol7[mCursor];
    }

    Col8ElemType
    Get8AtCursor()
    {
        return mCol8[mCursor];
    }

    Col9ElemType
    Get9AtCursor()
    {
        return mCol9[mCursor];
    }

    // misc

    virtual void
    Dump(int from = 0, int to = -1) const
    {
        if (to == -1 || to > Size())
            to = Size();
        if (to < from)
            to = from;
        std::cout << "Dumping table from " << from << " to " << to
                  << " (table size=" << Size() << ", capacity=" << Capacity()
                  << ")" << std::endl;
        for (size_t i=0 ; i<mColNames.size() ; i++)
            if (mColNames[i] != String(""))
                std::cout << i+1 << "=" << mColNames[i] << ", ";
        std::cout << std::endl;
        for (int i=from ; i<to ; i++)
        {
            if (mCol1.Valid())
                std::cout << Get1(i) << ", ";
            if (mCol2.Valid())
                std::cout << Get2(i) << ", ";
            if (mCol3.Valid())
                std::cout << Get3(i) << ", ";
            if (mCol4.Valid())
                std::cout << Get4(i) << ", ";
            if (mCol5.Valid())
                std::cout << Get5(i) << ", ";
            if (mCol6.Valid())
                std::cout << Get6(i) << ", ";
            if (mCol7.Valid())
                std::cout << Get7(i) << ", ";
            if (mCol8.Valid())
                std::cout << Get8(i) << ", ";
            if (mCol9.Valid())
                std::cout << Get9(i) << ", ";
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }

    // direct access, use with care

    Col1T*
    GetColumn1()
    {
        return &mCol1;
    }

    Col2T*
    GetColumn2()
    {
        return &mCol2;
    }

    Col3T*
    GetColumn3()
    {
        return &mCol3;
    }

    Col4T*
    GetColumn4()
    {
        return &mCol4;
    }

    Col5T*
    GetColumn5()
    {
        return &mCol5;
    }

    Col6T*
    GetColumn6()
    {
        return &mCol6;
    }

    Col7T*
    GetColumn7()
    {
        return &mCol7;
    }

    Col8T*
    GetColumn8()
    {
        return &mCol8;
    }

    Col9T*
    GetColumn9()
    {
        return &mCol9;
    }

    // const direct access
    const Col1T*
    GetColumn1() const
    {
        return &mCol1;
    }

    const Col2T*
    GetColumn2() const
    {
        return &mCol2;
    }

    const Col3T*
    GetColumn3() const
    {
        return &mCol3;
    }

    const Col4T*
    GetColumn4() const
    {
        return &mCol4;
    }

    const Col5T*
    GetColumn5() const
    {
        return &mCol5;
    }

    const Col6T*
    GetColumn6() const
    {
        return &mCol6;
    }

    const Col7T*
    GetColumn7() const
    {
        return &mCol7;
    }

    const Col8T*
    GetColumn8() const
    {
        return &mCol8;
    }

    const Col9T*
    GetColumn9() const
    {
        return &mCol9;
    }

    void
    Append(const TableTem<Col1T, Col2T, Col3T, Col4T, Col5T, Col6T, Col7T, Col8T, Col9T>* t)
    {
        if(t==0)
            return;

        int needed = Size() + t->Size();
        if(needed > Capacity())
            Reserve(needed, true);

        for(int i=0 ; i<t->Size() ; i++)
            Add(t->Get1(i), t->Get2(i), t->Get3(i), t->Get4(i), t->Get5(i),
                t->Get6(i), t->Get7(i), t->Get8(i), t->Get9(i));
    }

private:

    Col1T mCol1;
    Col2T mCol2;
    Col3T mCol3;
    Col4T mCol4;
    Col5T mCol5;
    Col6T mCol6;
    Col7T mCol7;
    Col8T mCol8;
    Col9T mCol9;
    std::vector<String> mColNames;
    String mInfo;

};

} // namespace Table
} // namespace Core
} // namespace Impala

#endif

---