AggComputerImpl.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/exec/AggComputerImpl.h#9 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_AggComputerImpl_Included
#define Fennel_AggComputerImpl_Included

#include "fennel/exec/AggComputer.h"
#include "fennel/tuple/TupleData.h"

FENNEL_BEGIN_NAMESPACE

class FENNEL_EXEC_EXPORT CountAggComputer
    : public AggComputer
{
protected:
    inline uint64_t &interpretDatum(TupleDatum &);

    inline void clearAccumulatorImpl(
        TupleDatum &accumulatorDatum);
    inline void initAccumulatorImpl(
        TupleDatum &accumulatorDatum);
    inline void updateAccumulatorImpl(
        TupleDatum &accumulatorDatum);

public:
    // implement AggComputer
    virtual void computeOutput(
        TupleDatum &outputDatum,
        TupleDatum const &accumulatorDatum);
};

class FENNEL_EXEC_EXPORT CountStarAggComputer
    : public CountAggComputer
{
public:
    // implement AggComputer
    virtual void clearAccumulator(
        TupleDatum &accumulatorDatum);

    // implement AggComputer
    virtual void updateAccumulator(
        TupleDatum &accumulatorDatum,
        TupleData const &inputTuple);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest);

    virtual void updateAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);
};

class FENNEL_EXEC_EXPORT CountNullableAggComputer
    : public CountAggComputer
{
public:
    // implement AggComputer
    virtual void clearAccumulator(
        TupleDatum &accumulatorDatum);

    // implement AggComputer
    virtual void updateAccumulator(
        TupleDatum &accumulatorDatum,
        TupleData const &inputTuple);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest);

    virtual void updateAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);
};

class FENNEL_EXEC_EXPORT ExtremeAggComputer
    : public AggComputer
{
    StoredTypeDescriptor const *pTypeDescriptor;

    AggFunction aggFunction;

    bool isResultNull;

    inline void copyInputToAccumulator(
        TupleDatum &accumulatorDatum,
        TupleDatum const &inputDatum);

public:
    explicit ExtremeAggComputer(
        AggFunction aggFunctionInit,
        TupleAttributeDescriptor const &attrDesc);

    // implement AggComputer
    virtual void clearAccumulator(
        TupleDatum &accumulatorDatum);

    // implement AggComputer
    virtual void updateAccumulator(
        TupleDatum &accumulatorDatum,
        TupleData const &inputTuple);

    // implement AggComputer
    virtual void computeOutput(
        TupleDatum &outputDatum,
        TupleDatum const &accumulatorDatum);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest);

    virtual void updateAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple);
};

template <class T>
class SumAggComputer : public AggComputer
{
    bool isResultNull;

    inline T &interpretDatum(TupleDatum &datum)
    {
        assert(datum.cbData == sizeof(T));
        assert(datum.pData);
        return *reinterpret_cast<T *>(const_cast<PBuffer>(datum.pData));
    }

    inline T const &interpretDatum(TupleDatum const &datum)
    {
        assert(datum.cbData == sizeof(T));
        assert(datum.pData);
        return *reinterpret_cast<T const *>(datum.pData);
    }

public:
    // implement AggComputer
    virtual void clearAccumulator(TupleDatum &accumulatorDatum)
    {
        T &sum = interpretDatum(accumulatorDatum);
        sum = 0;

        isResultNull = true;
    }

    // implement AggComputer
    virtual void updateAccumulator(
        TupleDatum &accumulatorDatum,
        TupleData const &inputTuple)
    {
        assert(iInputAttr != -1);
        TupleDatum const &inputDatum = inputTuple[iInputAttr];
        if (!inputDatum.pData) {
            // SQL2003 Part 2 Section 10.9 General Rule 4.a
            // TODO jvs 6-Oct-2005:  we're supposed to queue a warning
            // for null value eliminated in set function
            return;
        } else {
            isResultNull = false;
        }
        T &sum = interpretDatum(accumulatorDatum);
        if (inputDatum.pData) {
            T input = interpretDatum(inputDatum);
            // TODO jvs 6-Oct-2005:  overflow check
            sum += input;
        }
    }

    // implement AggComputer
    virtual void computeOutput(
        TupleDatum &outputDatum,
        TupleDatum const &accumulatorDatum)
    {
        // Set output to alias accumulator value directly.
        outputDatum = accumulatorDatum;
        if (isResultNull) {
            outputDatum.pData = NULL;
        }
    }

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple)
    {
        accumulatorDatumDest.memCopyFrom(inputTuple[iInputAttr]);
        isResultNull = false;
    }

    virtual void initAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest)
    {
        accumulatorDatumDest.memCopyFrom(accumulatorDatumSrc);
        isResultNull = false;
    }

    virtual void updateAccumulator(
        TupleDatum &accumulatorDatumSrc,
        TupleDatum &accumulatorDatumDest,
        TupleData const &inputTuple)
    {
        TupleDatum const &inputDatum = inputTuple[iInputAttr];

        if (!accumulatorDatumSrc.pData) {
            accumulatorDatumDest.memCopyFrom(inputDatum);
        } else {
            T sumSrc = interpretDatum(accumulatorDatumSrc);
            T &sumDest = interpretDatum(accumulatorDatumDest);

            if (inputDatum.pData) {
                T sumInput = interpretDatum(inputDatum);
                sumDest = sumSrc + sumInput;
            } else {
                sumDest = sumSrc;
            }
        }
    }
};


FENNEL_END_NAMESPACE

#endif

// End AggComputerImpl.h

---