AdvancedPhysicalAbstractPipe.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_ADVANCEDPHYSICALNODE_H
#define PDB_ADVANCEDPHYSICALNODE_H

#include "AbstractPhysicalNode.h"

namespace pdb {

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

class AdvancedPhysicalAbstractPipe;
typedef std::shared_ptr<AdvancedPhysicalAbstractPipe> AdvancedPhysicalPipelineNodePtr;

enum AdvancedPhysicalPipelineTypeID {
  STRAIGHT,
  JOIN_SIDE,
  AGGREGATION
};

class AdvancedPhysicalAbstractPipe : public AbstractPhysicalNode {
 public:

  AdvancedPhysicalAbstractPipe(string &jobId,
                               const Handle<ComputePlan> &computePlan,
                               LogicalPlanPtr &logicalPlan,
                               ConfigurationPtr &conf,
                               vector<AtomicComputationPtr> &pipeComputations,
                               size_t id);

  PhysicalOptimizerResultPtr analyze(const StatisticsPtr &stats, int nextStageID) override;

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

  virtual PhysicalOptimizerResultPtr chainMe(int nextStageID,
                                             const StatisticsPtr &stats,
                                             PhysicalOptimizerResultPtr previous);

  virtual bool isChainable();

  virtual bool isPipelinable(AdvancedPhysicalPipelineNodePtr node);

  virtual bool isExecuted();

  virtual AdvancedPhysicalPipelineTypeID getType() = 0;

  virtual AdvancedPhysicalAbstractAlgorithmPtr selectOutputAlgorithm() = 0;

  virtual std::vector<AdvancedPhysicalAbstractAlgorithmPtr> getPossibleAlgorithms(const StatisticsPtr &stats) = 0;

  virtual AdvancedPhysicalAbstractAlgorithmPtr propose(std::vector<AdvancedPhysicalAbstractAlgorithmPtr> algorithms);

  const bool isJoining();

  const bool isAggregating();

  std::unordered_map<std::string, std::string> getProbingHashSets();

  const AdvancedPhysicalAbstractAlgorithmPtr &getSelectedAlgorithm() const;

  double getCost(const StatisticsPtr &stats) override;

  bool isSource();

  bool hasConsumers() override;

  bool isConsuming(Handle<SetIdentifier> &set) override;

  string getNodeIdentifier() override;

  AdvancedPhysicalPipelineNodePtr getAdvancedPhysicalNodeHandle();

  AtomicComputationPtr getPipelineComputationAt(size_t idx);

  const vector<AtomicComputationPtr> &getPipeComputations() const;

  const Handle<SetIdentifier> &getSourceSetIdentifier() const;

  void setSourceSetIdentifier(const Handle<SetIdentifier> &sourceSetIdentifier);

 protected:

  AdvancedPhysicalAbstractAlgorithmPtr selectedAlgorithm;

  vector<AtomicComputationPtr> pipeComputations;

  size_t id;

  Handle<SetIdentifier> sourceSetIdentifier;

};

}

#endif //PDB_ADVANCEDPHYSICALNODE_H