Column-oriented GPU-accelerated Database Management System
CoGaDB
/home/sebastian/gpudbms/trunk/cogadb/include/query_processing/column_processing/column_comparator.hpp
Go to the documentation of this file.
00001 #pragma once
00002 
00003 #include <query_processing/definitions.hpp>
00004 #include <query_processing/column_processing/definitions.hpp>
00005 #include <util/getname.hpp>
00006 #include <core/selection_expression.hpp>
00007 #include <core/lookup_array.hpp>
00008 
00009 namespace CoGaDB {
00010     namespace query_processing {
00011         namespace physical_operator {
00012 
00013             class ColumnComparatorOperation : public hype::queryprocessing::BinaryOperator<ColumnPtr, ColumnPtr, ColumnPtr> {
00014             public:
00015                 //typedef hype::queryprocessing::OperatorMapper_Helper_Template<ColumnPtr>::TypedOperatorPtr ColumnWise_TypedOperatorPtr;
00016                 typedef column_processing::cpu::TypedOperatorPtr TypedOperatorPtr;
00017 
00018                 ColumnComparatorOperation(const hype::SchedulingDecision& sched_dec,
00019                         TypedOperatorPtr left_child,
00020                         TypedOperatorPtr right_child,
00021                         Predicate op,
00022                         MaterializationStatus mat_stat = MATERIALIZE) : BinaryOperator<ColumnPtr, ColumnPtr, ColumnPtr>(sched_dec, left_child, right_child),
00023                 op_(op),
00024                 mat_stat_(mat_stat) {
00025                 }
00026 
00027                 virtual bool execute() {
00028                     if (!quiet && debug && verbose) std::cout << "Execute Column Operator CPU" << std::endl;
00029                      //assure we have a Value Value Predicate, meaning we compare to columns
00030                      assert(op_.getPredicateType()==ValueValuePredicate);
00031                      //compute the result TIDs
00032                      PositionListPtr tids = this->getInputDataLeftChild()->selection(this->getInputDataRightChild(),op_.getValueComparator()); 
00033                      //create a LookupArray, the improtant thing is that the tids are returned
00034                      //since we need a ColumnPtr to cosntruct a Lookup Array, we pass it the pointer of one of the childs
00035                      this->result_=createLookupArrayForColumn(this->getInputDataLeftChild(),tids);
00036                     
00037                     if (this->result_)
00038                         return true;
00039                     else
00040                         return false;
00041                 }
00042 
00043                 virtual ~ColumnComparatorOperation() {
00044                 }
00045             private:
00046                 Predicate op_;
00047                 MaterializationStatus mat_stat_;
00048             };
00049 
00050             column_processing::cpu::Physical_Operator_Map_Ptr map_init_function_cpu_column_comparison_operator();
00051             column_processing::cpu::TypedOperatorPtr create_CPU_ColumnComparatorOperator(column_processing::cpu::TypedLogicalNode& logical_node, const hype::SchedulingDecision&, column_processing::cpu::TypedOperatorPtr left_child, column_processing::cpu::TypedOperatorPtr right_child);
00052 
00053             //                  GPU_ColumnWise_TypedOperatorPtr create_GPU_ColumnComparatorOperator(GPU_ColumnWise_TypedLogicalNode& logical_node, const hype::SchedulingDecision&, GPU_ColumnWise_TypedOperatorPtr left_child, GPU_ColumnWise_TypedOperatorPtr right_child);
00054 
00055         }//end namespace physical_operator
00056 
00057         namespace logical_operator {
00058 
00059             class Logical_ColumnComparatorOperation : public hype::queryprocessing::TypedNode_Impl<ColumnPtr, physical_operator::map_init_function_cpu_column_comparison_operator> //init_function_Join_operator>
00060             {
00061             public:
00062 
00063                 Logical_ColumnComparatorOperation(Predicate pred,
00064                         hype::DeviceConstraint dev_constr = hype::DeviceConstraint(hype::CPU_ONLY))
00065                 : TypedNode_Impl<ColumnPtr, physical_operator::map_init_function_cpu_column_comparison_operator>(false, dev_constr),
00066                 op_(pred),
00067                 mat_stat_() {
00068                 }
00069 
00070                 virtual unsigned int getOutputResultSize() const {
00071                     return 0;
00072                 }
00073 
00074                 virtual double getCalculatedSelectivity() const {
00075                     return 1;
00076                 }
00077 
00078                 virtual std::string getOperationName() const {
00079                     return "ColumnComparatorOperation"; //util::getName(op_);
00080                 }
00081 
00082                 virtual Predicate getPredicate() const {
00083                     return op_;
00084                 }
00085 
00086                 const MaterializationStatus& getMaterializationStatus() const {
00087                     return mat_stat_;
00088                 }
00089                 
00090                 std::string toString(bool verbose) const{
00091                     std::string result="ColumnComparatorOperation";
00092                     if(verbose){
00093                         result+=" (";
00094                         result+=op_.toString();
00095                         result+=" )";
00096                         
00097                     }
00098                     return result;
00099                 }
00100             private:
00101                 Predicate op_;
00102                 MaterializationStatus mat_stat_;
00103             };
00104 
00105         }//end namespace logical_operator
00106 
00107     }//end namespace query_processing
00108 
00109 }; //end namespace CogaDB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines