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

Go to the documentation of this file.

#pragma once
#include <core/global_definitions.hpp>
#include <core/base_column.hpp>
#include <core/selection_expression.hpp>

namespace CoGaDB{

class LookupColumn;

class BaseTable{
        friend class LookupColumn;
        public:
        typedef shared_pointer_namespace::shared_ptr<BaseTable> TablePtr;
        /***************** constructors and destructor *****************/
        BaseTable(const std::string& name, const TableSchema& schema);

        //BaseTable(const std::string& name, const std::vector<ColumnPtr>& columns); //if we already have columns, we can use this constructor to pass them in the BaseTable without any copy effort
        virtual ~BaseTable();
        /***************** utility functions *****************/
        const std::string& getName() const throw();

        const TableSchema getSchema() const throw();

        virtual void print() = 0;
        virtual bool store() = 0;
        virtual bool load() = 0;
        virtual bool loadDatafromFile(std::string filepath) = 0;

        virtual const TablePtr materialize() const = 0;
        
        virtual bool addColumn(ColumnPtr) = 0;
        
        static const TablePtr createResultTable(TablePtr table, PositionListPtr tids, MaterializationStatus mat_stat, const std::string& operation_name);

        /***************** status report *****************/
        virtual unsigned int getNumberofRows() const throw();
        //virtual const unsigned int getSizeinBytes() const throw() =0;

        unsigned int getSizeinBytes() const throw(){
                const std::vector<ColumnPtr>& columns = this->getColumns();
                unsigned int size_in_bytes=0;
                std::vector<ColumnPtr>::const_iterator cit;
                for(cit=columns.begin();cit!=columns.end();++cit){
                        size_in_bytes+=(*cit)->getSizeinBytes();
                }
                return size_in_bytes;
        }

        void printSchema() const {
            TableSchema schema = getSchema();
            TableSchema::iterator it;
            for (it = schema.begin(); it != schema.end(); ++it) {

                if (it != schema.begin()) std::cout << ", ";
                std::cout << it->second;

            }
            std::cout << std::endl;

        }

        virtual bool isMaterialized() const throw() =0;

        /***************** relational operations *****************/
        static const TablePtr selection(TablePtr table, const std::string& column_name, const boost::any& value_for_comparison, const ValueComparator& comp, MaterializationStatus mat_stat=MATERIALIZE, ParallelizationMode comp_mode=SERIAL, const ComputeDevice comp_dev=CPU);

        static const TablePtr selection(TablePtr table, const KNF_Selection_Expression&, MaterializationStatus mat_stat=MATERIALIZE, ParallelizationMode comp_mode=SERIAL);

        static const TablePtr selection(TablePtr table, const Disjunction& disjunction, MaterializationStatus mat_stat=MATERIALIZE, ParallelizationMode comp_mode=SERIAL);
        
        static const TablePtr projection(TablePtr table, const std::list<std::string>& columns_to_select, MaterializationStatus mat_stat=MATERIALIZE, const ComputeDevice comp_dev=CPU);

        static const TablePtr join(TablePtr table1, const std::string& join_column_table1, TablePtr table2, const std::string& join_column_table2, 
                                                                                         JoinAlgorithm join_alg=SORT_MERGE_JOIN, MaterializationStatus mat_stat=MATERIALIZE, const ComputeDevice comp_dev=CPU);
        
        static const TablePtr crossjoin(TablePtr table1, TablePtr table2, MaterializationStatus mat_stat=MATERIALIZE);       
        

        //crossjoin(this->getInputDataLeftChild(), this->getInputDataRightChild(), mat_stat_);
        
        static const TablePtr sort(TablePtr table, const std::string& column_name, SortOrder order=ASCENDING, MaterializationStatus mat_stat=MATERIALIZE, ComputeDevice comp_dev=CPU);
        //assumes stable sort!
        static const TablePtr sort(TablePtr table, const std::list<std::string>& column_names, SortOrder order=ASCENDING, MaterializationStatus mat_stat=MATERIALIZE, ComputeDevice comp_dev=CPU);
        
        static const TablePtr groupby(TablePtr table, const std::string& grouping_column, const std::string& aggregation_column, const std::string& result_column_name, AggregationMethod agg_meth=SUM, ComputeDevice comp_dev=CPU);
        
        static const TablePtr groupby(TablePtr table, const std::list<std::string>& grouping_columns, std::list<std::pair<std::string,AggregationMethod> > aggregation_functions, ComputeDevice comp_dev=CPU);        
        /***************** Aggregation Functions *****************/
        static TablePtr ColumnConstantOperation(TablePtr tab, const std::string& col_name, const boost::any& value, const std::string& result_col_name, ColumnAlgebraOperation operation, const ComputeDevice comp_dev = CPU);
        static TablePtr ColumnAlgebraOperation(TablePtr tab, const std::string& col1_name, const std::string& col2_name, const std::string& result_col_name, ColumnAlgebraOperation operation, const ComputeDevice comp_dev  = CPU);
        static TablePtr AddConstantValueColumnOperation(TablePtr tab, const std::string& col_name, AttributeType type, const boost::any& value, const ComputeDevice comp_dev  = CPU);
               
        
        
        /***************** read and write operations at BaseTable level *****************/
        virtual const Tuple fetchTuple(const TID& id) const = 0;

        virtual bool insert(const Tuple& t) = 0;

        virtual bool update(const std::string& attribute_name, const boost::any& value) = 0;

        virtual bool remove(const std::string& attribute_name, const boost::any& value) = 0;

        virtual const ColumnPtr getColumnbyName(const std::string& column_name) const throw() = 0;
        
        protected:
        virtual const std::vector<ColumnPtr>& getColumns() const = 0;
        //const TablePtr groupby(const std::string& grouping_column, const std::string& aggregation_column,  AggregationMethod agg_meth=SUM, ComputeDevice comp_dev=CPU) const;

        // std::vector<ColumnPtr> columns_;
        std::string name_;
        TableSchema schema_;
};

typedef BaseTable::TablePtr TablePtr;


}; //end namespace CogaDB