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

Go to the documentation of this file.

#pragma once
#include <core/global_definitions.hpp>
#include <core/base_table.hpp>


namespace CoGaDB{

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

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

//      const TableSchema getSchema() const throw();

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

        virtual const TablePtr materialize() const;
        
        virtual bool addColumn(ColumnPtr);

        /***************** status report *****************/
        unsigned int getNumberofRows() const throw();
//      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)->size();
//              }
//              return size_in_bytes;
//      }
        bool isMaterialized() const throw();

        /***************** relational operations *****************/
//      virtual const TablePtr selection(const std::string& column_name, const boost::any& value_for_comparison, const ValueComparator& comp, const ComputeDevice& comp_dev) const;// = 0;

//      virtual const TablePtr projection(const std::list<std::string>& columns_to_select, const ComputeDevice comp_dev) const;// = 0;

//      virtual const TablePtr join(TablePtr table, const std::string& join_column_table1, const std::string& join_column_table2, const ComputeDevice comp_dev) const;// = 0;

//      virtual const TablePtr sort(const std::string& column_name, SortOrder order, ComputeDevice comp_dev) const;// = 0;

//      virtual const TablePtr groupby(const std::string& grouping_column, const std::string& aggregation_column,  AggregationMethod agg_meth=SUM, ComputeDevice comp_dev=CPU) const;// = 0;
        /***************** read and write operations at table level *****************/
        const Tuple fetchTuple(const TID& id) const;

        bool insert(const Tuple& t);

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

        bool remove(const std::string& attribute_name, const boost::any& value);
        
        const ColumnPtr getColumnbyName(const std::string& column_name) const throw();

        protected:
        virtual const std::vector<ColumnPtr>& getColumns() const;


        /***************** relational operations that return lookup tables *****************/
//      const std::vector<TID> lookup_selection(const std::string& column_name, const boost::any& value_for_comparison, const ValueComparator& comp, const ComputeDevice& comp_dev) const;

//      //const TablePtr projection(const std::list<std::string>& columns_to_select, const ComputeDevice comp_dev) const;

//      const std::vector<TID_Pair> lookup_join(TablePtr table, const std::string& join_column_table1, const std::string& join_column_table2, const ComputeDevice comp_dev) const;

//      const TablePtr lookup_sort(const std::string& column_name, SortOrder order, ComputeDevice comp_dev) const;

//      //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 shared_pointer_namespace::shared_ptr<Table> MaterializedTablePtr;

const TableSchema mergeTableSchemas(const TableSchema& schema1, const std::string& join_attributname_table1,
                                                                                                const TableSchema& schema2, const std::string& join_attributname_table2);


//typedef Table::TablePtr TablePtr;

}; //end namespace CogaDB