/home/sebastian/gpudbms/trunk/hype-library/include/query_processing/physical_query_plan.hpp

Go to the documentation of this file.

#pragma once

//#include <core/scheduling_decision.hpp>

//#include <boost/shared_ptr.hpp>

#include <query_processing/typed_operator.hpp>
#include <query_processing/unary_operator.hpp>
#include <query_processing/binary_operator.hpp>

namespace hype {
    namespace queryprocessing {

        template <typename Type>
        class PhysicalQueryPlan {
        public:
            typedef typename OperatorMapper_Helper_Template<Type>::TypedOperatorPtr TypedOperatorPtr;
            typedef typename OperatorMapper_Helper_Template<Type>::TypedNodePtr TypedNodePtr;
            typedef typename OperatorMapper_Helper_Template<Type>::PhysicalQueryPlanPtr PhysicalQueryPlanPtr;
            //typedef typename OperatorMapper_Helper_Template<Type>::TypedOperator TypedOperator;

            PhysicalQueryPlan(TypedOperatorPtr root) : root_(root) {
                timeNeeded = 0;
                timeEstimated = 0;
            }

            bool run() {
                bool retVal = false;
                double begin = double(hype::core::getTimestamp());
                if (root_) {
                    retVal = root_->run();
                }
                timeNeeded = double( hype::core::getTimestamp()) - begin;
                return retVal;
            }
            
            const Type getResult() {
                return root_->getResult();
            }

            /*
            template <typename CallableType>
            void reverse_level_order(CallableType f){

            }*/

            //copy
            //print

            void print() {
                if (timeNeeded > 0) {
                    printResults();
                } else {
                    std::cout << "PhysicalQueryPlan:" << std::endl;
                    root_->print();
                    timeEstimated = root_->getRecursiveExecutionTimeInNanoseconds();
                    std::cout << "Estimated Time (total): " << timeEstimated / 1000000 << "ms (" << timeEstimated << "ns)" << std::endl;
                }
            }

            void printResults() {
                std::cout << "Measured Values:" << std::endl;
                root_->printResult();
                std::cout << "Estimated Time (total): " << timeEstimated / 1000000 << "ms (" << timeEstimated << "ns)" << std::endl;
                std::cout << "Measured Time (total): " << (timeNeeded) / 1000000 << "ms (" << timeNeeded << "ns)" << std::endl;
                std::cout << "Estimation Error: " << 1 - (timeEstimated / timeNeeded) << std::endl;
            }

            void setTimeNeeded(double ns) {
                timeNeeded = ns;
            }
        private:
            double timeNeeded;
            double timeEstimated;
            TypedOperatorPtr root_;
        };

        //typedef boost::shared_ptr<PhysicalQueryPlan> PhysicalQueryPlanPtr;

    }; //end namespace queryprocessing
}; //end namespace hype