WriteUserSetBase.h

Go to the documentation of this file.

//
// Created by dimitrije on 3/17/18.
//

#ifndef PDB_WRITEUSERSETBASE_H
#define PDB_WRITEUSERSETBASE_H

#include "Computation.h"
#include "VectorSink.h"
#include "PDBString.h"
#include "TypeName.h"
#include "mustache.h"

namespace pdb {

template <class OutputClass>
class WriteUserSetBase : public Computation {

public:

  WriteUserSetBase () = default;

  WriteUserSetBase (std :: string dbName, std :: string setName) {
    this->dbName = dbName;
    this->setName = setName;
    this->outputType = getTypeName<OutputClass>();
  }

  void setUpAndCopyFrom(void* target, void* source) const override {
    new (target) WriteUserSetBase<OutputClass> ();
    WriteUserSetBase<OutputClass>& fromMe = *((WriteUserSetBase<OutputClass> *) source);
    WriteUserSetBase<OutputClass>& toMe = *((WriteUserSetBase<OutputClass> *) target);

    toMe.outputType = fromMe.outputType;
    toMe.dbName = fromMe.dbName;
    toMe.setName = fromMe.setName;
  }

  void deleteObject(void* deleteMe) override {
    deleter(deleteMe, this);
  }

  size_t getSize(void* forMe) override {
    return sizeof(WriteUserSetBase<OutputClass>);
  }

  ComputeSinkPtr getComputeSink(TupleSpec& consumeMe, TupleSpec& projection, ComputePlan& plan) override {
    return std::make_shared<VectorSink<OutputClass>>(consumeMe, projection);
  }

  void setOutput(std::string dbName, std::string setName) override {
    this->dbName = dbName;
    this->setName = setName;
  }

  void setDatabaseName(std::string dbName) {
    this->dbName = dbName;
  }

  std::string getDatabaseName() override {
    return dbName;
  }

  void setSetName(std::string setName) {
    this->setName = setName;
  }

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

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

  ComputationTypeID getComputationTypeID() override {
    return WriteUserSetTypeID;
  }

  std::string getOutputType() override {
    if (outputType == "") {
      outputType = getTypeName<OutputClass>();
    }
    return outputType;
  }

  int getNumInputs() override {
    return 1;
  }

  std::string getIthInputType(int i) override {
    if (i == 0) {
      return this->getOutputType();
    } else {
      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];
    return toTCAPString(inputTupleSet.getTupleSetName(),
                        inputTupleSet.getColumnNamesToKeep(),
                        inputTupleSet.getColumnNamesToApply(),
                        computationLabel,
                        outputTupleSetName,
                        outputColumnNames,
                        addedOutputColumnName);
  }

  std::string toTCAPString(std::string inputTupleSetName,
                           std::vector<std::string>& inputColumnNames,
                           std::vector<std::string>& inputColumnsToApply,
                           int computationLabel,
                           std::string& outputTupleSetName,
                           std::vector<std::string>& outputColumnNames,
                           std::string& addedOutputColumnName) {

    //Names for output stuff
    outputTupleSetName = inputTupleSetName + "_out";
    outputColumnNames.emplace_back("");
    addedOutputColumnName = "";

    // the template we are going to use to create the TCAP string for this ScanUserSet
    mustache::mustache writeSetTemplate{"{{outputTupleSetName}}( {{outputColumnNames}}) <= "
                                         "OUTPUT ( {{inputTupleSetName}} ( {{inputColumnsToApply}} ), "
                                         "'{{setName}}', '{{dbName}}', '{{computationType}}_{{computationLabel}}')\n"};


    // the data required to fill in the template
    mustache::data writeSetData;
    writeSetData.set("outputTupleSetName", outputTupleSetName);
    writeSetData.set("outputColumnNames", outputColumnNames[0]);
    writeSetData.set("inputTupleSetName", inputTupleSetName);
    writeSetData.set("inputColumnsToApply", inputColumnsToApply[0]); //TODO? Only consider first column
    writeSetData.set("computationType", getComputationType());
    writeSetData.set("computationLabel", std::to_string(computationLabel));
    writeSetData.set("setName", std::string(setName));
    writeSetData.set("dbName", std::string(dbName));


    // update the state of the computation
    this->setTraversed(true);
    this->setOutputTupleSetName(outputTupleSetName);
    this->setOutputColumnToApply(addedOutputColumnName);

    // return the TCAP string
    return writeSetTemplate.render(writeSetData);
  }

  bool needsMaterializeOutput() override {
    return true;
  }

protected:

  String dbName;

  String setName;

  String outputType = "";
};

}

#endif //PDB_WRITEUSERSETBASE_H