/home/sebastian/gpudbms/trunk/cogadb/include/query_processing/column_computation_algebra_operator.hpp

Go to the documentation of this file.

#pragma once

#include <query_processing/definitions.hpp>
#include <util/getname.hpp>

namespace CoGaDB {
    namespace query_processing {
        namespace physical_operator {

            class CPU_ColumnAlgebraOperator : public hype::queryprocessing::UnaryOperator<TablePtr, TablePtr> {
                                public:
                                        typedef hype::queryprocessing::OperatorMapper_Helper_Template<TablePtr>::TypedOperatorPtr TypedOperatorPtr;

                                        CPU_ColumnAlgebraOperator(const hype::SchedulingDecision& sched_dec,
                                                            TypedOperatorPtr child,
                                                            const std::string& column1_name,
                                                            const std::string& column2_name,
                                                            const std::string& result_col_name, 
                                                            ColumnAlgebraOperation operation)
                                                                                 : UnaryOperator<TablePtr,TablePtr>(sched_dec, child),
                                                                                column1_name_(column1_name), 
                                                                                column2_name_(column2_name), 
                                                                                result_column_name_(result_col_name),
                operation_(operation) {
                                        }

                                        virtual bool execute() {
                                            /*
                                            if(!this->getInputData()->ColumnAlgebraOperation(column1_name_,column2_name_,result_column_name_,operation_,CoGaDB::CPU)){
                                                return false;
                                            }
                                            
                                            this->result_=this->getInputData();
                                            */
                                            this->result_=BaseTable::ColumnAlgebraOperation(this->getInputData(),column1_name_,column2_name_,result_column_name_,operation_,CoGaDB::CPU);

                    if (this->result_) {
                        setResultSize(((TablePtr) this->result_)->getNumberofRows());
                                                return true;
                    } else
                                                return false;
                                        }

                virtual ~CPU_ColumnAlgebraOperator() {
                }
                                private:
                                        std::string column1_name_;
                                        std::string column2_name_;
                                        std::string result_column_name_;
                                        CoGaDB::ColumnAlgebraOperation operation_;
                        };

            class GPU_ColumnAlgebraOperator : public hype::queryprocessing::UnaryOperator<TablePtr, TablePtr> {
                                public:
                                        typedef hype::queryprocessing::OperatorMapper_Helper_Template<TablePtr>::TypedOperatorPtr TypedOperatorPtr;

                                        GPU_ColumnAlgebraOperator(const hype::SchedulingDecision& sched_dec,
                                                            TypedOperatorPtr child,
                                                            const std::string& column1_name,
                                                            const std::string& column2_name,
                                                            const std::string& result_col_name, 
                                                            ColumnAlgebraOperation operation) : UnaryOperator<TablePtr,TablePtr>(sched_dec, child),
                                                            column1_name_(column1_name), 
                                                            column2_name_(column2_name), 
                                                            result_column_name_(result_col_name),
                                                            operation_(operation) {
                                        }

                                        virtual bool execute() {
                                            
                                            this->result_=BaseTable::ColumnAlgebraOperation(this->getInputData(),column1_name_,column2_name_,result_column_name_,operation_,CoGaDB::GPU);

                    if (this->result_) {
                        setResultSize(((TablePtr) this->result_)->getNumberofRows());
                                                return true;
                    } else
                                                return false;
                                        }

                virtual ~GPU_ColumnAlgebraOperator() {
                }
                                private:
                                        std::string column1_name_;
                                        std::string column2_name_;
                                        std::string result_column_name_;
                                        CoGaDB::ColumnAlgebraOperation operation_;
                        };

                        Physical_Operator_Map_Ptr map_init_function_column_algebra_operator();
                        TypedOperatorPtr create_CPU_ColumnAlgebra_Operator(TypedLogicalNode& logical_node, const hype::SchedulingDecision&, TypedOperatorPtr left_child, TypedOperatorPtr right_child);
                        TypedOperatorPtr create_GPU_ColumnAlgebra_Operator(TypedLogicalNode& logical_node, const hype::SchedulingDecision&, TypedOperatorPtr left_child, TypedOperatorPtr right_child);

                }//end namespace physical_operator

                //extern Map_Init_Function init_function_sort_operator;

                //Map_Init_Function init_function_sort_operator=physical_operator::map_init_function_column_algebra_operator; //boost::bind();

        namespace logical_operator {

                        class Logical_ColumnAlgebraOperator : public hype::queryprocessing::TypedNode_Impl<TablePtr,physical_operator::map_init_function_column_algebra_operator> //init_function_sort_operator>
                        {
                                public:

                                        Logical_ColumnAlgebraOperator(const std::string& column1_name,
                                                     const std::string& column2_name,
                                                     const std::string& result_col_name, 
                                                     ColumnAlgebraOperation operation,
                                                     hype::DeviceConstraint dev_constr = CoGaDB::RuntimeConfiguration::instance().getGlobalDeviceConstraint())
                                                                 : TypedNode_Impl<TablePtr,physical_operator::map_init_function_column_algebra_operator>(false,dev_constr), 
                                                                        column1_name_(column1_name), 
                                                                        column2_name_(column2_name), 
                                                                        result_column_name_(result_col_name),
                operation_(operation) {
                                        }

                                        virtual unsigned int getOutputResultSize() const {
                                                return 10;
                                        }

                virtual double getCalculatedSelectivity() const {
                                                return 0.1;
                                        }

                                        virtual std::string getOperationName() const {
                                                return "ColumnAlgebraOperator";
                                        }
                                        std::string toString(bool verbose) const{
                                            std::string result="ColumnAlgebraOperator";
                                            if(verbose){
                                                result+=" (";
                                                result+=result_column_name_;
                                                result+="=";                                                
                                                result+=util::getName(operation_);
                                                result+="(";
                                                result+=column1_name_;
                                                result+=",";
                                                result+=column2_name_;
                                                result+=")";

                                                result+=")";
                                            }
                                            return result;

                                        }
                                        const std::string& getColumn1Name() {
                                                return column1_name_;
                                        }

                                        const std::string& getColumn2Name() {
                                                return column2_name_;
                                        }

                                        const std::string& getResultColumnName() {
                                                return result_column_name_;
                                        }                                        

                                        CoGaDB::ColumnAlgebraOperation getColumnAlgebraOperation(){
                                                return operation_;
                                        }    
                        private:
                                        std::string column1_name_;
                                        std::string column2_name_;
                                        std::string result_column_name_;
                                        CoGaDB::ColumnAlgebraOperation operation_;
                        };

                }//end namespace logical_operator

        }//end namespace query_processing

}; //end namespace CogaDB