AbstractAggregateComp.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_AGG_COMP
#define ABSTRACT_AGG_COMP

#include "Computation.h"
#include "DataTypes.h"
#include "SimpleSingleTableQueryProcessor.h"
#include "DataProxy.h"
#include "PageCircularBufferIterator.h"
#include "ScanUserSet.h"
#include "DataTypes.h"
#include <vector>


namespace pdb {

class AbstractAggregateComp : public Computation {

public:

    AbstractAggregateComp() = default;

    virtual SimpleSingleTableQueryProcessorPtr getCombinerProcessor(std::vector<HashPartitionID> nodePartitionIds) = 0;

    virtual SimpleSingleTableQueryProcessorPtr getAggregationProcessor(HashPartitionID id) = 0;

    virtual SimpleSingleTableQueryProcessorPtr getAggOutProcessor() = 0;

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

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

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

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

    void setBatchSize(int batchSize) override {
        this->batchSize = batchSize;
    }

    int getBatchSize() {
        return this->batchSize;
    }

    virtual void setIterator(PageCircularBufferIteratorPtr iterator) = 0;

    virtual void setProxy(DataProxyPtr proxy) = 0;

    virtual void setDatabaseName(std::string dbName) = 0;

    virtual void setSetName(std::string setName) = 0;

    ComputationTypeID getComputationTypeID() override {
        return AbstractAggregateCompTypeID;
    }

    bool needsMaterializeOutput() override {
        return this->materializeAggOut;
    }

    void setHashTable(void* hashTableLocation) {
        this->materializeAggOut = false;
        this->whereHashTableSitsForThePartition = hashTableLocation;
    }

    bool isUsingCombiner() override {
        return useCombinerOrNot;
    }

    void setUsingCombiner(bool useCombinerOrNot) override {
        this->useCombinerOrNot = useCombinerOrNot;
    }


protected:
    int numPartitions = -1;

    int numNodes = -1;

    int batchSize = -1;

    void* whereHashTableSitsForThePartition = nullptr;

    bool materializeAggOut = false;

    bool useCombinerOrNot = true;
};
}

#endif