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

Go to the documentation of this file.

#pragma once

#include <core/column_base_typed.hpp>
#include <iostream>
#include <fstream>

#include <stdint.h>

#include <gpu/gpu_base_column.hpp>
#include <util/begin_ptr.hpp>

#include <hardware_optimizations/simd_acceleration.hpp>

namespace CoGaDB{

template<typename T>
class Column : public ColumnBaseTyped<T>{
        public:
        /***************** constructors and destructor *****************/
        Column(const std::string& name, AttributeType db_type);
        virtual ~Column();

        virtual bool insert(const boost::any& new_value);
        bool insert(const T& new_value);        
        template <typename InputIterator>
        bool insert(InputIterator first, InputIterator last);

        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();
        virtual void print() const throw();
        virtual size_t size() const throw();
        virtual unsigned int getSizeinBytes() const throw();

        virtual const ColumnPtr copy() const;
        virtual const ColumnPtr materialize() throw();
        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 T& operator[](const int index);
        //inline T& operator[](const int index) __attribute__((always_inline));

        virtual const PositionListPtr selection(const boost::any& value_for_comparison, const ValueComparator comp);  
        virtual const PositionListPtr selection(ColumnPtr comparison_column, const ValueComparator comp);
        
        std::vector<T>& getContent();

        private:

                struct Type_TID_Comparator {
                        inline bool operator() (std::pair<T,TID> i, std::pair<T,TID> j) { return (i.first<j.first);}
                } type_tid_comparator;

        
        std::vector<T> values_;
};



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

        
        template<class T>
        Column<T>::Column(const std::string& name, AttributeType db_type) : ColumnBaseTyped<T>(name,db_type), type_tid_comparator(), values_(){

        }

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

        }

        template<class T>
        std::vector<T>& Column<T>::getContent(){
                return values_;
        }
        /*
        template<class T>
        const PositionListPtr Column<T>::selection(const boost::any& value_for_comparison, const ValueComparator comp){
            
            T value;
            
            if(value_for_comparison.type()!=typeid(T)){ 
                //catch some special cases
                if(typeid(T)==typeid(float) && value_for_comparison.type()==typeid(int)){
                    value = boost::any_cast<int>(value_for_comparison);
                }else{
                    std::cout << "Fatal Error!!! Typemismatch for column " << this->name_ << std::endl;
                    std::cout << "Column Type: " << typeid(T).name() << " filter value type: " << value_for_comparison.type().name() << std::endl;
                    std::cout << "File: " << __FILE__ << " Line: " << __LINE__ << std::endl;
                    exit(-1);
                }
            }else{
                //everything fine, filter value matches type of column
                value = boost::any_cast<T>(value_for_comparison);
            }

            //T value = boost::any_cast<T>(value_for_comparison);
            PositionListPtr result_tids;

            result_tids = PositionListPtr(new PositionList());
            //one third rule for selections: assume a selectivity of 0.3, meaning we need roughly 0.3 times of the input to store the result 
            //this optimizatio nshould minimize the number of reallocations during the insertion process
            //result_tids->reserve(0.3*this->size()); 
            
             unsigned int array_size=this->size()+1;
            //calls new internally   
             result_tids->resize(array_size);
             //tids.reserve(array_size);
             //get pointer
             unsigned int* array_tids=hype::util::begin_ptr(*result_tids);
             assert(array_tids!=NULL);
             unsigned int pos=0;

            if(!quiet) std::cout << "Using CPU for Selection..." << std::endl;
            //unsigned int array_size = this->size();
            //for(TID i=0;i<array_size;i++){

                    //boost::any value = column->get(i);
                    //val = values_[i];
            T* array=hype::util::begin_ptr(values_);
            
            if(comp==EQUAL){
                for(TID i=0;i<array_size;i++){
                    if(value==array[i]){
                            //result_tids->push_back(i);
                            array_tids[pos++]=i;
                    }
                }
            }else if(comp==LESSER){
                for(TID i=0;i<array_size;i++){
                    if(array[i]<value){
                            //result_table->insert(this->fetchTuple(i));
                            //result_tids->push_back(i);
                            array_tids[pos++]=i;
                    }
                }
             }else if(comp==LESSER_EQUAL){
                for(TID i=0;i<array_size;i++){
                    if(array[i]<=value){
                            //result_tids->push_back(i);
                            //result_table->insert(this->fetchTuple(i));
                            array_tids[pos++]=i;
                    }
                } 
            }else if(comp==GREATER){
                for(TID i=0;i<array_size;i++){
                    if(array[i]>value){
                            //result_tids->push_back(i);
                            //result_table->insert(this->fetchTuple(i));
                            array_tids[pos++]=i;
                    }
                }    
            }else if(comp==GREATER_EQUAL){
                for(TID i=0;i<array_size;i++){
                    if(array[i]>=value){
                            //result_tids->push_back(i);
                            //result_table->insert(this->fetchTuple(i));
                            array_tids[pos++]=i;
                    }
                }      
            }else{

            }
            //shrink to actual result size
            result_tids->resize(pos);
            return result_tids;
        }*/
  
        
    
        
        

        template<class T>
        const PositionListPtr Column<T>::selection(ColumnPtr comparison_column, const ValueComparator comp){
            //same behaviour as in parent class
            return CoGaDB::ColumnBaseTyped<T>::selection(comparison_column, comp);
        }
        

        template<class T>
        bool Column<T>::insert(const boost::any& new_value){
                if(new_value.empty()) return false;
                if(typeid(T)==new_value.type()){
                         T value = boost::any_cast<T>(new_value);
                         values_.push_back(value);
                         return true;
                }
                return false;
        }

        template<class T>
        bool Column<T>::insert(const T& new_value){
                values_.push_back(new_value);
                return true;
        }


        template <typename T> 
        template <typename InputIterator>
        bool Column<T>::insert(InputIterator first, InputIterator last){
                this->values_.insert(this->values_.end(),first,last);
                return true;
        }

        template<class T>
        bool Column<T>::update(TID tid, const boost::any& new_value){
                if(new_value.empty()) return false;
                if(typeid(T)==new_value.type()){
                         T value = boost::any_cast<T>(new_value);
                         values_[tid]=value;
                         return true;
                }else{
                        std::cout << "Fatal Error!!! Typemismatch for column " << this->name_ << std::endl; 
                }
                return false;
        }

        template<class T>
        bool Column<T>::update(PositionListPtr tids, const boost::any& new_value){
                if(!tids)
                        return false;
        if(new_value.empty()) return false;
                if(typeid(T)==new_value.type()){
                         T value = boost::any_cast<T>(new_value);
                         for(unsigned int i=0;i<tids->size();i++){
                                TID tid=(*tids)[i];
                                values_[tid]=value;
                         }
                         return true;
                }else{
                        std::cout << "Fatal Error!!! Typemismatch for column " << this->name_ << std::endl; 
                }
                return false;           
        }
        



        template<class T>
        bool Column<T>::remove(TID tid){
                values_.erase(values_.begin()+tid);
                return true;
        }
        
        template<class T>
        bool Column<T>::remove(PositionListPtr tids){
                if(!tids)
                        return false;
                //test whether tid list has at least one element, if not, return with error
                if(tids->empty())
                        return false;           

                //assert();

                typename PositionList::reverse_iterator rit;

                for (rit = tids->rbegin(); rit!=tids->rend(); ++rit)
                        values_.erase(values_.begin()+(*rit));

                /*
                //delete tuples in reverse order, otherwise the first deletion would invalidate all other tids
                unsigned int i=tids->size()-1;
                while(true)     
                        TID = (*tids)[i];
                        values_.erase(values_.begin()+tid);             
                        if(i==0) break;
                }*/
                
                
                return true;                    
        }

        template<class T>
        bool Column<T>::clearContent(){
                values_.clear();
                return true;
        }

        template<class T>
        const boost::any Column<T>::get(TID tid){
                if(tid<values_.size())
                        return boost::any(values_[tid]);
                else{
                        std::cout << "fatal Error!!! Invalid TID!!! Attribute: " << this->name_ << " TID: " << tid  << std::endl;
                }
                return boost::any();
        }

        template<class T>
        void Column<T>::print() const throw(){
                std::cout << "| " << this->name_ << " |" << std::endl;
                std::cout << "________________________" << std::endl;
                for(unsigned int i=0;i<values_.size();i++){
                        std::cout << "| " << values_[i] << " |" << std::endl;
                }
        }
        template<class T>
        size_t Column<T>::size() const throw(){
                return values_.size();
        }

        template<class T>
        const ColumnPtr Column<T>::materialize() throw(){
            return this->copy(); 
         }
        template<class T>
        const ColumnPtr Column<T>::copy() const{
                return ColumnPtr(new Column<T>(*this));
        }
        
        template<class T>
        const ColumnPtr Column<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());
            //if(!CoGaDB::quiet && CoGaDB::verbose && CoGaDB::debug) std::cout << "Result size:" << tid_list->size() << std::endl;
            //if(!CoGaDB::quiet && CoGaDB::verbose && CoGaDB::debug) std::cout << "Column size: " << this->size() << std::endl;
            for(unsigned int i=0;i<tid_list->size();i++){
                //std::cout << "tid: " << (*tid_list)[i] << std::endl;
                //std::cout << "value: " << (*this)[(*tid_list)[i]] << std::endl;
                data[i]=(*this)[(*tid_list)[i]];
            }
            return ColumnPtr(result); 
        }        
        
        
        /***************** relational operations on Columns which return lookup tables *****************/
//      template<class T>
//      const std::vector<TID> Column<T>::sort(const ComputeDevice comp_dev) const {

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

//      template<class T> 
//      const std::vector<TID> Column<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> Column<T>::sort_merge_join(ColumnPtr join_Column, const ComputeDevice comp_dev) const{

//              return std::vector<TID_Pair>();
//      }
//      template<class T>
//      const std::vector<TID_Pair> Column<T>::nested_loop_join(ColumnPtr join_Column, const ComputeDevice comp_dev) const{

//              return std::vector<TID_Pair>();
//      }
        template<class T>
        bool Column<T>::store(const std::string& path_){
                //string path("data/");
                std::string path(path_);
                path += "/";
                path += this->name_;
                           if(!quiet && verbose && debug) std::cout << "Writing Column " << this->getName() << " to File " << path << std::endl;
                std::ofstream outfile (path.c_str(),std::ios_base::binary | std::ios_base::out);
                boost::archive::binary_oarchive oa(outfile);

                oa << values_;

                outfile.flush();
                outfile.close();
                return true;
        }
        template<class T>
        bool Column<T>::load(const std::string& path_){
                std::string path(path_);
                if(!quiet && verbose && debug) std::cout << "Loading column '" << this->name_ << "' from path '" << path << "'..." << std::endl;
                //string path("data/");
                path += "/";
                path += this->name_;
                
                if(!quiet && verbose && debug) std::cout << "Opening File '" << path << "'..." << std::endl;
                std::ifstream infile (path.c_str(),std::ios_base::binary | std::ios_base::in);
                boost::archive::binary_iarchive ia(infile);
                ia >> values_;
                infile.close();


                return true;
        }
        template<class T>
        bool Column<T>::isMaterialized() const  throw(){
                return true;
        }
        
        template<class T>
        bool Column<T>::isCompressed() const  throw(){
                return false;
        }

        template<class T>
        T& Column<T>::operator[](const int index){
                
                return values_[index];
        }



/*
        template<>
        bool& Column<bool>::operator[](const int index) const{
                
                return false; // values_[index];
        }*/
        template<class T>
        unsigned int Column<T>::getSizeinBytes() const throw(){
                        return values_.capacity()*sizeof(T);
        }

        //total template specialization
        template<>
        inline unsigned int Column<std::string>::getSizeinBytes() const throw(){
                unsigned int size_in_bytes=0;
                for(unsigned int i=0;i<values_.size();++i){
                        size_in_bytes+=values_[i].capacity();
                }
                //return values_.size()*sizeof(T);
                return size_in_bytes;
        }

/***************** End of Implementation Section ******************/




}; //end namespace CogaDB