Column-oriented GPU-accelerated Database Management System
CoGaDB
|
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/lookup_array.hpp> 00007 00008 00009 namespace CoGaDB { 00010 namespace query_processing { 00011 namespace physical_operator { 00012 00013 class CPU_PositionList_Operator : 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 CPU_PositionList_Operator(const hype::SchedulingDecision& sched_dec, 00019 TypedOperatorPtr left_child, 00020 TypedOperatorPtr right_child, 00021 PositionListOperation 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 PositionListPtr tids; 00030 00031 assert(!this->getInputDataLeftChild()->isMaterialized() && !this->getInputDataLeftChild()->isCompressed() ); 00032 //Workaround: We can only work on ColumnPtr and cannot mix PostionListPtr in the plan, so we need a workaround 00033 //create LookupArrays, which store tid lists in the filter outine and get TID lists in the Positionlistroutine 00034 PositionListPtr tids_left_child=getPositonListfromLookupArray(this->getInputDataLeftChild()); 00035 PositionListPtr tids_right_child=getPositonListfromLookupArray(this->getInputDataRightChild()); 00036 00037 assert(tids_left_child!=NULL); 00038 assert(tids_right_child!=NULL); 00039 00040 if (op_ == POSITIONLIST_INTERSECTION) { 00041 tids = computePositionListIntersection(tids_left_child, tids_right_child); 00042 } else if (op_ == POSITIONLIST_UNION) { 00043 tids = computePositionListUnion(tids_left_child, tids_right_child); 00044 } 00045 00046 //the only interesting point here is the Positionlist, we need a pointer to a real Column to cosntruct the obejct, so we use one of the childs 00047 this->result_ = createLookupArrayForColumn(this->getInputDataLeftChild(),tids); 00048 00049 if (this->result_) 00050 return true; 00051 else 00052 return false; 00053 } 00054 00055 virtual ~CPU_PositionList_Operator() { 00056 } 00057 private: 00058 PositionListOperation op_; 00059 MaterializationStatus mat_stat_; 00060 }; 00061 00062 column_processing::cpu::Physical_Operator_Map_Ptr map_init_function_cpu_positionlist_operator(); 00063 column_processing::cpu::TypedOperatorPtr create_CPU_PositionList_Operator(column_processing::cpu::TypedLogicalNode& logical_node, const hype::SchedulingDecision&, column_processing::cpu::TypedOperatorPtr left_child, column_processing::cpu::TypedOperatorPtr right_child); 00064 00065 // GPU_ColumnWise_TypedOperatorPtr create_GPU_ColumnAlgebraOperator(GPU_ColumnWise_TypedLogicalNode& logical_node, const hype::SchedulingDecision&, GPU_ColumnWise_TypedOperatorPtr left_child, GPU_ColumnWise_TypedOperatorPtr right_child); 00066 00067 }//end namespace physical_operator 00068 00069 namespace logical_operator { 00070 00071 class Logical_PositionList_Operator : public hype::queryprocessing::TypedNode_Impl<ColumnPtr, physical_operator::map_init_function_cpu_positionlist_operator> //init_function_Join_operator> 00072 { 00073 public: 00074 00075 Logical_PositionList_Operator(PositionListOperation op, 00076 MaterializationStatus mat_stat = MATERIALIZE, 00077 hype::DeviceConstraint dev_constr = hype::DeviceConstraint(hype::CPU_ONLY)) 00078 : TypedNode_Impl<ColumnPtr, physical_operator::map_init_function_cpu_positionlist_operator>(false, dev_constr), 00079 op_(op), 00080 mat_stat_(mat_stat) { 00081 } 00082 00083 virtual unsigned int getOutputResultSize() const { 00084 return 0; 00085 } 00086 00087 virtual double getCalculatedSelectivity() const { 00088 return 1; 00089 } 00090 00091 virtual std::string getOperationName() const { 00092 return "PositionList_Operator"; //util::getName(op_); 00093 } 00094 00095 virtual PositionListOperation getPositionListOperation() const { 00096 return op_; 00097 } 00098 00099 const MaterializationStatus& getMaterializationStatus() const { 00100 return mat_stat_; 00101 } 00102 std::string toString(bool verbose) const { 00103 std::string result="PositionList_Operator"; 00104 if(verbose){ 00105 result+=" ("; 00106 result+= util::getName(op_); 00107 result+=")"; 00108 } 00109 return result; 00110 } 00111 private: 00112 PositionListOperation op_; 00113 MaterializationStatus mat_stat_; 00114 }; 00115 00116 }//end namespace logical_operator 00117 00118 }//end namespace query_processing 00119 00120 }; //end namespace CogaDB