AdvancedPhysicalAbstractAlgorithm.h

Go to the documentation of this file.

/*****************************************************************************
 *                                                                           *
 *  Copyright 2018 Rice University                                           *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *      http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 *****************************************************************************/

#ifndef PDB_ADVANCEDPHYSICALALGORITHM_H
#define PDB_ADVANCEDPHYSICALALGORITHM_H

#include "AdvancedPhysicalOptimizer/AdvancedPhysicalAbstractPipe.h"

namespace pdb {


enum AdvancedPhysicalAbstractAlgorithmTypeID {
  SELECTION_ALGORITHM,
  AGGREGATION_ALGORITHM,
  JOIN_ALGORITHM,
  JOIN_BROADCASTED_HASHSET_ALGORITHM,
  JOIN_SHUFFLED_HASHSET_ALGORITHM,
  JOIN_SUFFLE_SET_ALGORITHM
};

class AdvancedPhysicalAbstractAlgorithm;
typedef std::shared_ptr<AdvancedPhysicalAbstractAlgorithm> AdvancedPhysicalAbstractAlgorithmPtr;

class AdvancedPhysicalAbstractAlgorithm {

public:

  AdvancedPhysicalAbstractAlgorithm(const AdvancedPhysicalPipelineNodePtr &handle,
                                      const std::string &jobID,
                                      bool isProbing,
                                      bool isOutput,
                                      Handle<SetIdentifier> source,
                                      Handle<ComputePlan> computePlan,
                                      const LogicalPlanPtr &logicalPlan,
                                      const ConfigurationPtr &conf);

  virtual PhysicalOptimizerResultPtr generate(int nextStageID, const StatisticsPtr &stats) = 0;

  virtual PhysicalOptimizerResultPtr generatePipelined(int nextStageID,
                                                       const StatisticsPtr &stats,
                                                       std::vector<AdvancedPhysicalPipelineNodePtr> &pipesToPipeline);

  virtual AdvancedPhysicalAbstractAlgorithmTypeID getType() = 0;

protected:

  virtual DataStatistics approximateResultSize(const StatisticsPtr &stats);

  void updateConsumers(const Handle<SetIdentifier> &sink,
                       DataStatistics approxSize,
                       const StatisticsPtr &stats);

  void includeHashComputation();

  void extractAtomicComputations();

  void extractHashSetsToProbe();

  std::list<AdvancedPhysicalPipelineNodePtr> pipeline;

  std::string jobID;

  list<AtomicComputationPtr> pipelineComputations;

  unordered_map<std::string, std::string> probingHashSets;

  LogicalPlanPtr logicalPlan;

  Handle<ComputePlan> computePlan;

  ConfigurationPtr conf;

  Handle<SetIdentifier> sink;

  Handle<SetIdentifier> source;

  bool isProbing;

  bool isOutput;
};

}


#endif //PDB_ADVANCEDPHYSICALALGORITHM_H