/home/sebastian/gpudbms/trunk/cogadb/include/compression/dictionary_compressed_column.hpp

Go to the documentation of this file.

#pragma once

#include <core/compressed_column.hpp>

namespace CoGaDB{
        
template<class T>
class DictionaryCompressedColumn : public CompressedColumn<T>{
        public:
        /***************** constructors and destructor *****************/
        DictionaryCompressedColumn(const std::string& name, AttributeType db_type);
        virtual ~DictionaryCompressedColumn();

        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);
        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();

        virtual const ColumnPtr copy() const;

        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);

        private:
            std::vector<uint32_t> ids_;
            typedef std::map<T,uint32_t> Dictionary;
            Dictionary dictionary_;
            std::vector<T> reverse_lookup_vector_; 
            uint32_t maximal_id_;
            
        
};


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

        
        template<class T>
        DictionaryCompressedColumn<T>::DictionaryCompressedColumn(const std::string& name, AttributeType db_type) : CompressedColumn<T>(name,db_type), ids_(), dictionary_(), reverse_lookup_vector_(), maximal_id_(0){

        }

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

        }

        template<class T>
        bool DictionaryCompressedColumn<T>::insert(const boost::any& new_Value){

            T value = boost::any_cast<T>(new_Value);
            
            return this->insert(value);
        }
        
        template<class T>
        bool DictionaryCompressedColumn<T>::insert(const T& value){
            typename Dictionary::iterator it = dictionary_.find(value);
            if(it!=dictionary_.end()){
                ids_.push_back(it->second);
            }else{
                ids_.push_back(maximal_id_);
                dictionary_.insert(std::make_pair(value,maximal_id_));
                //element id is position in reverse lookup vector to get the real value in O(1) time
                reverse_lookup_vector_.push_back(value); 
                maximal_id_++;
                
            }
            
            return true;            
        }
        
        template <typename T> 
        template <typename InputIterator>
        bool DictionaryCompressedColumn<T>::insert(InputIterator first, InputIterator last) {
                for (; first != last; ++first) {
                        if (!this->insert(*first)) {
                                return false;
                        }
                }
                return true;
        }        

        

        template<class T>
        const boost::any DictionaryCompressedColumn<T>::get(TID tid){

                return boost::any(this->operator [](tid));
        }

        template<class T>
        void DictionaryCompressedColumn<T>::print() const throw(){
                std::cout << "| " << this->name_ << " (Dictionary Compressed) |" << std::endl;
                std::cout << "________________________" << std::endl;
                for(unsigned int i=0;i<this->size();i++){
                        std::cout << "| " << reverse_lookup_vector_[ids_[i]] << " |" << std::endl;
                }           
        }
        template<class T>
        size_t DictionaryCompressedColumn<T>::size() const throw(){

                return ids_.size();
        }
        template<class T>
        const ColumnPtr DictionaryCompressedColumn<T>::copy() const{
                return ColumnPtr(new DictionaryCompressedColumn<T>(*this));
        }

        template<class T>
        bool DictionaryCompressedColumn<T>::update(TID index, const boost::any& new_Value){
            T value = boost::any_cast<T>(new_Value);
            if(index>=this->size()) return false;
          
            typename Dictionary::iterator it = dictionary_.find(value);
            if(it!=dictionary_.end()){
                //ids_.push_back(it->second);
                ids_[index]=it->second;
                //reverse_lookup_vector_[ids[index]]=it->first;
            }else{
                //ids_.push_back(maximal_id_);
                ids_[index]=maximal_id_;
                dictionary_.insert(std::make_pair(value,maximal_id_));
                //element id is position in reverse lookup vector to get the real value in O(1) time
                reverse_lookup_vector_.push_back(value); 
                maximal_id_++;
                
            }
        }

        template<class T>
        bool DictionaryCompressedColumn<T>::update(PositionListPtr tids, const boost::any& new_Value){
            if(!tids)
                    return false;
            //test whether tid list has at least one element, if not, return with error
            if(tids->empty())
                    return false;
            
            bool result=true;
            for(unsigned int i=0;i<tids->size();i++){
                result = result && this->update((*tids)[i],new_Value);
            }
                return result;          
        }
        
        template<class T>
        bool DictionaryCompressedColumn<T>::remove(TID tid){
                ids_.erase(ids_.begin()+tid);
                return true;
        
        }
        
        template<class T>
        bool DictionaryCompressedColumn<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;           

                typename PositionList::reverse_iterator rit;
                //delete tuples in reverse order, otherwise the first deletion would invalidate all other tids
                for (rit = tids->rbegin(); rit!=tids->rend(); ++rit){
                        ids_.erase(ids_.begin()+(*rit));
                }
                        
                return true;                    
        }


        template<class T>
        bool DictionaryCompressedColumn<T>::clearContent(){
            this->ids_.clear();
            this->dictionary_.clear();
            this->reverse_lookup_vector_.clear();
            this->maximal_id_=0;
            return true;
        }
        
        template<class T>
        bool DictionaryCompressedColumn<T>::store(const std::string& path_){
                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 << ids_;
                oa << dictionary_;
                oa << reverse_lookup_vector_;
                oa << this->maximal_id_;

                outfile.flush();
                outfile.close();
                return true;
        }
        template<class T>
        bool DictionaryCompressedColumn<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 >> ids_;
                ia >> dictionary_;
                ia >> reverse_lookup_vector_;
                ia >> this->maximal_id_;
                infile.close();


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

        template<class T>
        T& DictionaryCompressedColumn<T>::operator[](const int index){
                return this->reverse_lookup_vector_[ids_[index]];
        }

        template<class T>
        unsigned int DictionaryCompressedColumn<T>::getSizeinBytes() const throw(){
                return 0; //ids_.capacity()+this->reverse_lookup_vector_.capacity()+this->dictionary_.capacity()+sizeof(DictionaryCompressedColumn<T>) ; //return values_.capacity()*sizeof(T);
        }

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



}; //end namespace CogaDB