Column-oriented GPU-accelerated Database Management System
CoGaDB
/home/sebastian/gpudbms/trunk/cogadb/include/query_processing/column_processing/positionlist_operator.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/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
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines