/home/sebastian/gpudbms/trunk/cogadb/include/compression/tmp/db2/compression/rle_compressed_column.hpp

Go to the documentation of this file.

#pragma once

#include <core/compressed_column.hpp>
#include <sstream>
#include <string> 
#include <fstream> 
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/map.hpp>

namespace CoGaDB{

        template<class T>
        class RLECompressedColumn : public CompressedColumn<T>{
        public:
                RLECompressedColumn(const std::string& name, AttributeType db_type);
                ~RLECompressedColumn();

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

                bool update(TID tid, const boost::any& new_value);
                bool update(PositionListPtr tid, const boost::any& new_value);  

                bool remove(TID tid);
                //assumes tid list is sorted ascending
                bool remove(PositionListPtr tid);
                bool clearContent();

                const boost::any get(TID tid);
                void print() const throw();
                size_t size() const throw();
                unsigned int getSizeinBytes() const throw();

                const ColumnPtr copy() const;

                bool store(const std::string& path);
                bool load(const std::string& path);

                T& operator[](const int index);

        private:
                std::vector<T> values_;
                std::vector<unsigned char> count_;
                std::string last_compressed_value;
        };


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


        template<class T>
        RLECompressedColumn<T>::RLECompressedColumn(const std::string& name, AttributeType db_type) : CompressedColumn<T>(name, db_type), values_(), count_(), last_compressed_value() {}

        template<class T>
        RLECompressedColumn<T>::~RLECompressedColumn() {}

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

        template<class T>
        bool RLECompressedColumn<T>::insert(const T& new_value){
                //row
                if (!values_.empty() &&
                        new_value == values_.back() &&
                        count_.back() < 255) {
                                count_[count_.size() - 1] = count_.back() + 1;
                }
                else {
                        values_.push_back(new_value);
                        count_.push_back(0);
                }

                return true;
        }

        std::string rle_encode_string(const std::string s) {
                int count = 0;
                std::stringstream result_str;
                char found = NULL;
                for (unsigned int i = 0; i < s.length(); i++) {

                        const char c = s[i];

                        //              for(const char c : s) {
                        if (i == 0) { //first char
                                found = c;
                        }
                        else if (found == c) { //following char
                                if (count >= 255) { //if count is bigger than max char write new char
                                        result_str << (char) 255 << (char) found;
                                        count = count - 255;
                                }
                                else count++;
                        }
                        else { //new char, wirte last found, reset count
                                result_str << (char) count << (char) found;
                                found = c;
                                count = 0;
                        }
                }
                result_str << (char) count << (char) found; //write last char
                return result_str.str();
        }

        template<>
        bool RLECompressedColumn<std::string>::insert(const std::string& new_value){
                std::string result = rle_encode_string(new_value);
                if ((!values_.empty()) &&
                        (result == values_.back()) &&
                        (count_.back() < 255)) {
                                count_[count_.size()-1] = count_.back()+1;
                }
                else {
                        values_.push_back(result);
                        count_.push_back(0);
                }
                return true;
        }


        template <typename T> 
        template <typename InputIterator>
        bool RLECompressedColumn<T>::insert(InputIterator first, InputIterator last){        
                for (InputIterator it = first; it != last; it++) 
                {
                        insert(*it);
                }
                return true;
        }

        template<class T>
        const boost::any RLECompressedColumn<T>::get(TID tid){
                return boost::any(operator [] (tid));
        }

        template<class T>
        void RLECompressedColumn<T>::print() const throw(){
                std::cout << "| " << this->name_ << " |" << std::endl;
                std::cout << "________________________" << std::endl;
                for(unsigned int i=0;i<values_.size() && i<count_.size();i++){
                        std::cout << "| " << values_[i] << " * " << (int) count_[i] + 1 << " | " << std::endl;
                }
        }
        template<class T>
        size_t RLECompressedColumn<T>::size() const throw(){
                int size_sum = 0;
                for (unsigned int i = 0; i < count_.size(); i++)
                {
                        size_sum += count_[i] + 1;
                }
                return size_sum;
        }
        template<class T>
        const ColumnPtr RLECompressedColumn<T>::copy() const{
                return ColumnPtr(new RLECompressedColumn<T>(*this));
        }

        template<class T>
        bool RLECompressedColumn<T>::update(TID tid, const boost::any& new_value){
                if(new_value.empty()) {
                        std::cout << "E: Update: new value is empty" << std::endl;
                        return false;
                }
                unsigned int len = size();
                if(len <= tid) {
                        return false;
                }
                if(typeid(T)==new_value.type()){
                        //cast value to T
                        T new_T_value = boost::any_cast<T>(new_value);

                        //decode value
                        std::vector<T> decoded_values_;
                        for (unsigned int i = 0; i < len; i++)
                        {
                                T value = operator[](i);
                                decoded_values_.push_back(value);
                        }

                        //update decoded_values_
                        decoded_values_[tid] = new_T_value;

                        //update values_ -> clearContent + insert(decoded) -> encoded values_
                        clearContent();
                        for (unsigned int i = 0; i < decoded_values_.size(); i++) 
                        {
                                T v = decoded_values_[i];
                                insert(v);
                        }

                        return true;
                }else{
                        std::cout << "Fatal Error!!! Typemismatch for column " << this->name_ << std::endl; 
                }
                return false;
        }

        template<class T>
        bool RLECompressedColumn<T>::update(PositionListPtr tids, const boost::any& new_value){
                if(!tids)
                        return false;
                if(new_value.empty()) return false;
                TID tid;
                for(unsigned int i=0;i<tids->size();i++){
                        tid=(*tids)[i];
                        update(tid, new_value);
                }
                return true;    
        }

        template<class T>
        bool RLECompressedColumn<T>::remove(TID tid){
                unsigned int len = size();
                if (len <= tid) 
                        return false;

                //decode value
                std::vector<T> decoded_values_;
                for (unsigned int i = 0; i < len; i++)
                {
                        T value = operator[](i);
                        decoded_values_.push_back(value);
                }

                //erase value at tid
                decoded_values_.erase(decoded_values_.begin()+tid);

                //update values_ -> clearContent + insert(decoded) -> encoded values_
                clearContent();
                for (unsigned int i = 0; i < decoded_values_.size(); i++) 
                {
                        T v = decoded_values_[i];
                        insert(v);
                }

                return true;
        }

        template<class T>
        bool RLECompressedColumn<T>::remove(PositionListPtr tids){
                if(!tids)
                        return false;
                if(tids->empty())
                        return false;           

                typename PositionList::reverse_iterator rit;

                for (rit = tids->rbegin(); rit!=tids->rend(); ++rit)
                {
                        remove(*rit);
                }

                return true;            
        }

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

        template<class T>
        bool RLECompressedColumn<T>::store(const std::string& path_){
                std::string path1(path_);
                path1 += "/";
                path1 += this->name_;
                path1 += " values";

                std::ofstream outfile1 (path1.c_str(), std::ios_base::binary | std::ios_base::out);
                boost::archive::binary_oarchive oa1(outfile1);
                oa1 << values_;
                outfile1.flush();
                outfile1.close();

                std::string path2(path_);
                path2 += "/";
                path2 += this->name_;
                path2 += " count";

                std::ofstream outfile2 (path2.c_str(), std::ios_base::binary | std::ios_base::out);
                boost::archive::binary_oarchive oa2(outfile2);
                oa2 << count_;
                outfile2.flush();
                outfile2.close();

                return true;
        }

        template<class T>
        bool RLECompressedColumn<T>::load(const std::string& path_){
                std::string path1(path_);

                path1 += "/";
                path1 += this->name_;
                path1 += " values";

                std::ifstream infile1 (path1.c_str(),std::ios_base::binary | std::ios_base::in);
                boost::archive::binary_iarchive ia1(infile1);
                ia1 >> values_;
                infile1.close();

                std::string path2(path_);

                path2 += "/";
                path2 += this->name_;
                path2 += " count";

                std::ifstream infile2 (path2.c_str(),std::ios_base::binary | std::ios_base::in);
                boost::archive::binary_iarchive ia2(infile2);
                ia2 >> count_;
                infile2.close();

                return true;
        }

        template<>
        std::string& RLECompressedColumn<std::string>::operator[](const int index){
                //find value
                unsigned int row_sum = 0;
                unsigned int i = 0;
                for (; row_sum + count_[i] < index; i++)
                {
                        row_sum += ((count_[i]) + 1);
                }
                std::string encoded = values_[i];

                //decode string
                std::string decoded;
                for (unsigned int j = 0; j < encoded.size(); j+=2)
                {
                        unsigned char c = encoded[j];
                        for (unsigned int k = 0; k <= c; k++)
                        {
                                decoded.push_back(encoded[j+1]);
                        }
                }

                last_compressed_value = decoded;
                return last_compressed_value;
        }

        template<class T>
        T& RLECompressedColumn<T>::operator[](const int index){
                int row_sum = 0;
                unsigned int i = 0;
                for (; row_sum + count_[i] < index; i++)
                {
                        row_sum += ((count_[i]) + 1);
                }
                return values_[i];
        }


        template<class T>
        unsigned int RLECompressedColumn<T>::getSizeinBytes() const throw(){
                return (values_.capacity()*sizeof(T)) + (values_.capacity()*sizeof(char));
        }

        template<>
        inline unsigned int RLECompressedColumn<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 size_in_bytes;
        }

};