/home/sebastian/gpudbms/trunk/cogadb/include/core/base_column.hpp

Go to the documentation of this file.

#pragma once
//STL includes
#include <typeinfo>
//boost includes
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/binary_object.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/list.hpp>
//CoGaDB includes
#include <core/global_definitions.hpp>

namespace CoGaDB{
/* \brief a PositionList is an STL vector of TID values*/
typedef std::vector<TID> PositionList;
/* \brief a PositionListPtr is a a references counted smart pointer to a PositionList object*/
typedef shared_pointer_namespace::shared_ptr<PositionList> PositionListPtr;
/* \brief a PositionListPair is an STL pair consisting of two PositionListPtr objects
 *  \details This type is returned by binary operators, e.g., joins*/
typedef std::pair<PositionListPtr,PositionListPtr> PositionListPair;
/* \brief a PositionListPairPtr is a a references counted smart pointer to a PositionListPair object*/
typedef shared_pointer_namespace::shared_ptr<PositionListPair> PositionListPairPtr;

class Table; //forward declaration

class ColumnBase{
        public:
        typedef shared_pointer_namespace::shared_ptr<ColumnBase> ColumnPtr;
        /***************** constructors and destructor *****************/
        ColumnBase(const std::string& name, AttributeType db_type);
        virtual ~ColumnBase();
        /***************** methods *****************/   
        virtual bool insert(const boost::any& new_Value)=0;
        virtual bool update(TID tid, const boost::any& new_Value)=0;
        virtual bool update(PositionListPtr tids, const boost::any& new_value) = 0;             
        virtual bool remove(TID tid)=0;
        virtual bool remove(PositionListPtr tid)=0;     
        virtual const boost::any get(TID tid)=0; //not const, because operator [] does not provide const return type and the child classes rely on []
        virtual void print() const throw()=0;
        virtual size_t size() const throw()=0;
        virtual unsigned int getSizeinBytes() const throw()=0;
        virtual const ColumnPtr copy() const=0;
        virtual const ColumnPtr gather(PositionListPtr tid_list)=0;        
        virtual const ColumnPtr materialize() throw() =0;
        /***************** relational operations on Columns which return a PositionListPtr/PositionListPairPtr *****************/
        virtual const PositionListPtr sort(SortOrder order=ASCENDING)= 0; 
        virtual const PositionListPtr selection(const boost::any& value_for_comparison, const ValueComparator comp)= 0;
        virtual const PositionListPtr selection(ColumnPtr, const ValueComparator comp)= 0;        
        virtual const PositionListPtr parallel_selection(const boost::any& value_for_comparison, const ValueComparator comp, unsigned int number_of_threads) = 0;
        virtual const PositionListPairPtr hash_join(ColumnPtr join_column)=0;
        virtual const PositionListPairPtr parallel_hash_join(ColumnPtr join_column,unsigned int number_of_threads)=0;
        virtual const PositionListPairPtr sort_merge_join(ColumnPtr join_column)=0;
        virtual const PositionListPairPtr nested_loop_join(ColumnPtr join_column)=0;
        /***************** column algebra operations *****************/ 
        virtual bool add(const boost::any& new_Value) = 0;
        virtual bool add(ColumnPtr column) = 0;
        virtual bool minus(const boost::any& new_Value) = 0;
        virtual bool minus(ColumnPtr column) = 0;       
        virtual bool multiply(const boost::any& new_Value) = 0;
        virtual bool multiply(ColumnPtr column) = 0;
        virtual bool division(const boost::any& new_Value) = 0; 
        virtual bool division(ColumnPtr column) = 0;    
        /***************** persistency operations *****************/            
        virtual bool store(const std::string& path) = 0;
        virtual bool load(const std::string& path) = 0;
        /***************** misc operations *****************/   
        virtual bool isMaterialized() const  throw() = 0;
        virtual bool isCompressed() const  throw() = 0; 
        virtual const std::type_info& type() const throw() = 0;
        AttributeType getType() const throw();
        const std::string getName() const throw();
        void setName(const std::string& value) throw();        
        virtual bool is_equal(ColumnPtr column) = 0;    
        virtual int compareValuesAtIndexes(TID id1, TID id2) = 0;       
        
        protected:
        std::string name_;
        AttributeType db_type_;
//      Table& table_;
};

typedef ColumnBase::ColumnPtr ColumnPtr;

typedef std::vector<ColumnPtr> ColumnVector;
typedef shared_pointer_namespace::shared_ptr<ColumnVector> ColumnVectorPtr;

const ColumnPtr createColumn(AttributeType type, const std::string& name);

PositionListPtr computePositionListUnion(PositionListPtr tids1, PositionListPtr tids2);
PositionListPtr computePositionListIntersection(PositionListPtr tids1, PositionListPtr tids2);


}; //end namespace CogaDB


//extend boost namespace to add serialization feature to my own types
namespace boost {
namespace serialization {

template<class Archive>
void serialize(Archive & ar, std::pair<CoGaDB::AttributeType,std::string> & pair, const unsigned int ) //version)
{
        
    ar & pair.first;
    ar & pair.second;
    
}

} // namespace serialization
} // namespace boost