AbstractPhysicalNode.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_ABSTRACTPHYSICALNODE_H
#define PDB_ABSTRACTPHYSICALNODE_H

#include <memory>
#include <list>
#include "TupleSetJobStage.h"
#include "BroadcastJoinBuildHTJobStage.h"
#include "HashPartitionedJoinBuildHTJobStage.h"
#include "AggregationJobStage.h"
#include "AtomicComputation.h"
#include "AbstractJobStage.h"
#include "SetIdentifier.h"
#include "Handle.h"
#include "Statistics.h"

namespace pdb {

class PhysicalOptimizerResult;
class AbstractPhysicalNode;

typedef std::shared_ptr<PhysicalOptimizerResult> PhysicalOptimizerResultPtr;
typedef std::shared_ptr<AbstractPhysicalNode> AbstractPhysicalNodePtr;
typedef std::shared_ptr<AbstractPhysicalNode> AbstractPhysicalNodeWeakPtr;

struct PhysicalOptimizerResult {

  std::list<Handle<AbstractJobStage>> physicalPlanToOutput;

  std::list<Handle<SetIdentifier>> interGlobalSets;


  list<AbstractPhysicalNodePtr> createdSourceComputations;

  bool success;
};


class AbstractPhysicalNode {
public:

  AbstractPhysicalNode(string &jobId,
                       const Handle<ComputePlan> &computePlan,
                       LogicalPlanPtr &logicalPlan,
                       ConfigurationPtr &conf);

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

  virtual double getCost(const StatisticsPtr &stats) = 0;

  virtual bool hasConsumers() = 0;

  virtual bool isConsuming(Handle<SetIdentifier> &set) = 0;

  virtual std::string getNodeIdentifier() = 0;

  AbstractPhysicalNodePtr getHandle();

  virtual void removeConsumer(const AbstractPhysicalNodePtr &consumer) {
    consumers.remove(consumer);
    consumer->producers.remove(getHandle());
  }

  virtual void addConsumer(const pdb::AbstractPhysicalNodePtr &consumer) {
    consumers.push_back(consumer);
    consumer->producers.push_back(getHandle());
  }

  AbstractPhysicalNodePtr getConsumer(int idx);

  size_t getNumConsumers();

  AbstractPhysicalNodePtr getProducer(int idx);

  size_t getNumProducers();


  template<typename T>
  std::shared_ptr<T> to() {
    return std::dynamic_pointer_cast<T>(getHandle());
  }


 protected:

  std::string jobId;

  Handle<ComputePlan> computePlan;

  LogicalPlanPtr logicalPlan;

  ConfigurationPtr conf;

  std::list<AbstractPhysicalNodePtr> consumers;

  std::list<AbstractPhysicalNodeWeakPtr> producers;

  AbstractPhysicalNodeWeakPtr handle;

  Handle<SetIdentifier> getSetIdentifierFromComputation(Handle<Computation> computation);
};

}



#endif //PDB_ABSTRACTPHYSICALNODE_H