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

Go to the documentation of this file.

#pragma once

#include <core/column_base_typed.hpp>
#include <core/column.hpp>
#include <lookup_table/lookup_column.hpp>
#include <core/base_table.hpp>

namespace CoGaDB{

template<class T>
class LookupArray : public ColumnBaseTyped<T>{
        public:
        /***************** constructors and destructor *****************/
        LookupArray(const std::string& name, AttributeType db_type, ColumnPtr column, PositionListPtr tids);
        virtual ~LookupArray();

        virtual bool insert(const boost::any& new_Value);
        virtual bool insert(const T& new_Value);
        virtual bool update(TID tid, const boost::any& new_value);
        virtual bool update(PositionListPtr tid, const boost::any& new_value);  
        
        virtual bool remove(TID tid);
        //assumes tid list is sorted ascending
        virtual bool remove(PositionListPtr tid);
        virtual bool clearContent();
        
        virtual const boost::any get(TID tid);
        //virtual const boost::any* const getRawData()=0;
        virtual void print() const throw();
        virtual size_t size() const throw();
        virtual unsigned int getSizeinBytes() const throw();
        PositionListPtr getPositionList();

        virtual const ColumnPtr copy() const;
        virtual const ColumnPtr gather(PositionListPtr tid_list);

        virtual bool store(const std::string& path);
        virtual bool load(const std::string& path);
        virtual bool isMaterialized() const  throw();
        virtual bool isCompressed() const  throw();     
        virtual const ColumnPtr materialize() throw();

        
        virtual T& operator[](const int index);
        //inline T& operator[](const int index) __attribute__((always_inline));

        private:
        shared_pointer_namespace::shared_ptr<ColumnBaseTyped<T> > column_;
        PositionListPtr tids_;
};

inline ColumnPtr createLookupArrayForColumn(ColumnPtr col, PositionListPtr tids_)
{
    assert(col!=NULL);
    
    AttributeType type=col->getType();   
    std::string column_name=col->getName();
    
    if(type==INT){
            return ColumnPtr(new LookupArray<int>(column_name,INT,col,tids_));
    }else if(type==FLOAT){
            return ColumnPtr(new LookupArray<float>(column_name,FLOAT,col,tids_));
    }else if(type==VARCHAR){
            return ColumnPtr(new LookupArray<std::string>(column_name,VARCHAR,col,tids_));
    }else if(type==BOOLEAN){
            std::cout << "Fatal Error! invalid AttributeType: " << type << " for Column: " << column_name 
                      << " Note: bool is currently not supported, will be added again in the future!"<< std::endl;
            return ColumnPtr();
    }else{
            std::cout << "Fatal Error! invalid AttributeType: " << type << " for Column: " << column_name << std::endl;
            return ColumnPtr();
    }
}

inline PositionListPtr getPositonListfromLookupArray(ColumnPtr col){
    if(!col) return PositionListPtr(); 
    //is LookupArray?
    if(col->isMaterialized() || col->isCompressed()){
        //input is not LookupArray, so no Positionlist can be retrieved
        return PositionListPtr(); 
    }
    
    AttributeType type=col->getType();   

    
    if(type==INT){
        shared_pointer_namespace::shared_ptr<LookupArray<int> > lookup_array = shared_pointer_namespace::dynamic_pointer_cast<LookupArray<int> > (col);
        return lookup_array->getPositionList();           
    }else if(type==FLOAT){
        shared_pointer_namespace::shared_ptr<LookupArray<float> > lookup_array = shared_pointer_namespace::dynamic_pointer_cast<LookupArray<float> > (col);
        return lookup_array->getPositionList();              
    }else if(type==VARCHAR){
        shared_pointer_namespace::shared_ptr<LookupArray<std::string> > lookup_array = shared_pointer_namespace::dynamic_pointer_cast<LookupArray<std::string> > (col);
        return lookup_array->getPositionList();               
    }else if(type==BOOLEAN){
            std::cout << "Fatal Error! invalid AttributeType: " << type << " for Column: " << col->getName() 
                      << " Note: bool is currently not supported, will be added again in the future!"<< std::endl;
            return PositionListPtr();
    }else{
            std::cout << "Fatal Error! invalid AttributeType: " << type << " for Column: " <<  col->getName() << std::endl;
            return PositionListPtr();
    }
    

}


        //typedef shared_pointer_namespace::shared_ptr<LookupArray> LookupArrayPtr;

/***************** Start of Implementation Section ******************/

        
        template<class T>
        LookupArray<T>::LookupArray(const std::string& name, AttributeType db_type, ColumnPtr column, PositionListPtr tids) 
                                                : ColumnBaseTyped<T>(name, db_type),
                                                  column_( shared_pointer_namespace::static_pointer_cast<ColumnBaseTyped<T> > (column) ),
                                                  tids_(tids) {
        
                assert(column_!=NULL);
                assert(tids_!=NULL);
                assert(db_type==column->getType());

        }

        template<class T>
        LookupArray<T>::~LookupArray(){

        }

        template<class T>
        bool LookupArray<T>::insert(const boost::any& ){
                return false;
        }
        template<class T>
        bool LookupArray<T>::insert(const T& new_Value){
                return false;
        } 
        template<class T>
        bool LookupArray<T>::update(TID , const boost::any& ){
                return  false;
        }

        template<class T>
        bool LookupArray<T>::update(PositionListPtr, const boost::any&){
                return  false;                  
        }
        
        template<class T>
        bool LookupArray<T>::remove(TID ){

                return false;
        }
        
        //assumes tid list is sorted ascending
        template<class T>
        bool LookupArray<T>::remove(PositionListPtr){
                return false;
        }
        
        template<class T>
        bool LookupArray<T>::clearContent(){
            return false;
        }
        
        template<class T>
        const boost::any LookupArray<T>::get(TID tid){
                return boost::any((*this)[tid]);
        }

        template<class T>
        void LookupArray<T>::print() const throw(){
                
                const shared_pointer_namespace::shared_ptr<ColumnBaseTyped<T> > column = column_;
                const PositionListPtr tids = tids_;

                std::cout << "Lookup Array for Column " << column_->getName() << " ";
                if(column_->isMaterialized()){
                        std::cout << "which is a materialized Column" << std::endl;
                }else{
                        std::cout << "which is a LookupArray of a Lookup column" << std::endl;
                }
                std::cout << "| values | Translatetion TIDS | Index in Lookup Table |" << std::endl;
                for(unsigned int i=0;i<tids->size();i++){
                        std::cout << "| " << (*column_)[(*tids_)[i]] << " | " << (*tids_)[i] << " | " << i << " |" << std::endl;
                }


        }
        template<class T>
        size_t LookupArray<T>::size() const throw(){

                return tids_->size();
        }

        template<class T>
        const ColumnPtr LookupArray<T>::materialize() throw(){

            Column<T>* result = new Column<T>(this->name_,this->db_type_);
            std::vector<T>& data = result->getContent();
            data.resize(this->size());
            for(unsigned int i=0;i<this->size();i++){
                data[i]=(*this)[i];
            }
            return ColumnPtr(result); 
        }

        template<class T>
        const ColumnPtr LookupArray<T>::copy() const{
                PositionListPtr new_tids (new PositionList(*tids_));
                return ColumnPtr(new LookupArray<T>(this->name_,this->db_type_,this->column_,new_tids));
        }
        
        template<class T>
        const ColumnPtr LookupArray<T>::gather(PositionListPtr tid_list){
            Column<T>* result = new Column<T>(this->name_,this->db_type_);
            std::vector<T>& data = result->getContent();
            data.resize(tid_list->size());
            for(unsigned int i=0;i<tid_list->size();i++){              
                data[i]=(*this)[(*tid_list)[i]];
            }
            return ColumnPtr(result); 
        }    
        
        /***************** relational operations on LookupArrays which return lookup tables *****************/
//      template<class T>
//      const std::vector<TID> LookupArray<T>::sort(const ComputeDevice comp_dev) const {

//              return std::vector<TID>();
//      }

//      template<class T> 
//      const std::vector<TID> LookupArray<T>::selection(const boost::any& value_for_comparison, const ValueComparator comp, const ComputeDevice comp_dev) const {
//              return std::vector<TID>();
//      }
//      //join algorithms
//      template<class T>
//      const std::vector<TID_Pair> LookupArray<T>::sort_merge_join(ColumnPtr join_LookupArray, const ComputeDevice comp_dev) const{
//              return std::vector<TID_Pair>();
//      }
//      template<class T>
//      const std::vector<TID_Pair> LookupArray<T>::nested_loop_join(ColumnPtr join_LookupArray, const ComputeDevice comp_dev) const{
//              return false;
//      }
        template<class T>
        bool LookupArray<T>::store(const std::string&){
                return false;
        }
        template<class T>
        bool LookupArray<T>::load(const std::string&){
                return false;
        }
        template<class T>
        bool LookupArray<T>::isMaterialized() const  throw(){
                return false;
        }
        template<class T>
        bool LookupArray<T>::isCompressed() const  throw(){
                return false;
        }
        template<class T>
        T& LookupArray<T>::operator[](const int index){
                return (*column_)[(*tids_)[index]];
        }

        template<class T>
        unsigned int LookupArray<T>::getSizeinBytes() const throw(){
                return tids_->capacity()*sizeof(typename PositionList::value_type);
        }

        template<class T>
        PositionListPtr LookupArray<T>::getPositionList(){
            return this->tids_;
        }
        
/***************** End of Implementation Section ******************/


}; //end namespace CogaDB