AbstractPartitionComp.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 ABSTRACT_PARTITION_COMP_H
#define ABSTRACT_PARTITION_COMP_H

#include "Computation.h"
#include "VectorSink.h"
#include "ScanUserSet.h"
#include "TypeName.h"

namespace pdb {
template<class KeyClass, class ValueClass>
class AbstractPartitionComp : public Computation {

 public:


  virtual std::string getComputationType() override { 
    return "AbstractPartitionComp"; 
  }

  virtual ComputationTypeID getComputationTypeID() override {
    return AbstractPartitionCompID;
  }

  std::string getIthInputType(int i) override {
    if (i == 0) {
      return getTypeName<ValueClass>();
    } else {
      return "";
    }
  }

  int getNumInputs() override {
    return 1;
  }

  virtual std::string getOutputType() override {
    return "";
  };

  std::string toTCAPString(std::vector<InputTupleSetSpecifier> &inputTupleSets,
                           int computationLabel,
                           std::string &outputTupleSetName,
                           std::vector<std::string> &outputColumnNames,
                           std::string &addedOutputColumnName) override {

    if (inputTupleSets.empty()) {
      return "";
    }
    InputTupleSetSpecifier inputTupleSet = inputTupleSets[0];
    std::vector<std::string> childrenLambdaNames;
    std::string myLambdaName;
    return toTCAPString(inputTupleSet.getTupleSetName(),
                        inputTupleSet.getColumnNamesToKeep(),
                        inputTupleSet.getColumnNamesToApply(),
                        childrenLambdaNames,
                        computationLabel,
                        outputTupleSetName,
                        outputColumnNames,
                        addedOutputColumnName,
                        myLambdaName);
  }

  virtual std::string toTCAPString(std::string inputTupleSetName,
                           std::vector<std::string> &inputColumnNames,
                           std::vector<std::string> &inputColumnsToApply,
                           std::vector<std::string> &childrenLambdaNames,
                           int computationLabel,
                           std::string &outputTupleSetName,
                           std::vector<std::string> &outputColumnNames,
                           std::string &addedOutputColumnName,
                           std::string &myLambdaName) = 0;

  virtual void setOutput(std::string dbName, std::string setName) override {}

  virtual void setBatchSize(int batchSize) override {};

  virtual std::string getDatabaseName() override {
    return "";
  }

  std::string getSetName() override {
    return "";
  }

 virtual  ComputeSourcePtr getComputeSource(TupleSpec &outputScheme, ComputePlan &plan) override {
   return nullptr;
 }

  virtual ComputeSinkPtr getComputeSink(TupleSpec &consumeMe,
                                TupleSpec &projection,
                                ComputePlan &plan) override {
    return nullptr;
  }


  bool needsMaterializeOutput() override {
    return materializeSelectionOut;
  }


 void setNumPartitions (int numPartitions) {
    this->numPartitions = numPartitions;
 }

 int getNumPartitions () {
    return this->numPartitions;
 }

 void setNumNodes (int numNodes) {
    this->numNodes = numNodes;
 }

 int getNumNodes () {
    return this->numNodes;
 }


 protected:
  bool materializeSelectionOut = false;
  int numPartitions = 16;
  int numNodes = 2;

};

}

#endif //ABSTRACT_PARTITION_COMP_H