mariadb-columnstore-engine/utils/windowfunction/frameboundrange.h

/* Copyright (C) 2014 InfiniDB, 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; version 2 of
   the License.

   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., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

//  $Id: frameboundrange.h 3868 2013-06-06 22:13:05Z xlou $


#ifndef UTILS_FRAMEBOUNDRANGE_H
#define UTILS_FRAMEBOUNDRANGE_H


#include "framebound.h"


namespace windowfunction
{


/** @brief class FrameBoundRange
 *
 */
class FrameBoundRange : public FrameBound
{
public:
	/** @brief FrameBoundRange constructor
	 *  @param  t, frame type
	 *  @param  a, order by sort spec: asc | desc
	 *  @param  n, order by sort spec: null first | null last
	 *  @param  v, order by column data type
	 */
	FrameBoundRange(int t = 0, bool a = true, bool n = true)
		: FrameBound(t), fAsc(a), fNullFirst(n), fIsZero(false) {};

	/** @brief FrameBoundRange destructor
	 */
	virtual ~FrameBoundRange() {};

	/** @brief clone
	 */
	virtual FrameBound* clone() { return NULL; }  // abstract class

	/** @brief virtual void getBound
	 */
	int64_t getBound(int64_t, int64_t, int64_t);

	const std::string toString() const;

	void setTupleId(std::vector<uint64_t> ids)  { fTupleId = ids;   }
	std::vector<uint64_t> getTupleId() const    { return fTupleId;  }

	void setIndex(vector<int> idx)              { fIndex = idx;     }
	const std::vector<int>& getIndex() const    { return fIndex;    }

	void isZero(bool z) { fIsZero = z;    }
	bool isZero() const { return fIsZero; }

protected:

	// for range calculation
	// data, row meta data, order by column index, ascending | descending
	// [0]: order by; [1]: interval; [2]: [0] +/- [1]
	std::vector<uint64_t>                       fTupleId;
	std::vector<int>                            fIndex;

	// order by sort specification
	bool                                        fAsc;
	bool                                        fNullFirst;

	// in case expr evaluates to 0
	bool                                        fIsZero;

};


/** @brief struct ValueType
 *
 */
template<typename T>
struct ValueType
{
	T                                       fValue;
	bool                                    fIsNull;

	// constructor
	ValueType() : fValue(0), fIsNull(false) {}
};


/** @brief class FrameBoundConstantRange
 *
 */
template<typename T>
class FrameBoundConstantRange : public FrameBoundRange
{
public:
	/** @brief FrameBoundConstant constructor
	 *  @param  t, frame type
	 *  @param  a, order by sort spec: asc | desc
	 *  @param  n, order by sort spec: null first | null last
	 *  @param  c, constant value.  !! caller need to check NULL or negative value !!
	 */
	FrameBoundConstantRange(int t = 0, bool a = true, bool n = true, void* c = NULL)
		: FrameBoundRange(t, a, n)
	{
		fValue.fIsNull = (c == NULL);
		if (!fValue.fIsNull)
			fValue.fValue = *((T*) c);
	};

	/** @brief FrameBoundConstantRange destructor
	 */
	virtual ~FrameBoundConstantRange() {};

	/** @brief clone
	 */
	virtual FrameBound* clone()
	{ return new FrameBoundConstantRange(*this); }

	/** @brief virtual void getBound
	 */
	int64_t getBound(int64_t, int64_t, int64_t);

	const std::string toString() const;

protected:

	// find the range offset
	// i: partition upper bound
    // j: current row
	// k: partition lower bound
	virtual int64_t getPrecedingOffset(int64_t j, int64_t i);
	virtual int64_t getFollowingOffset(int64_t j, int64_t k);

	// validate value is not negative
	virtual void validate() {}

	// get value at fIndex[x]
	void getValue(ValueType<T>&, int64_t);
	T getValueByType(int64_t);

	// order by column value type
	ValueType<T> fValue;

};


/** @brief class FrameBoundExpressionRange
 *
 */
template<typename T>
class FrameBoundExpressionRange : public FrameBoundConstantRange<T>
{
public:
	/** @brief FrameBoundExpressionRange constructor
	 *  @param  t, frame type
	 *  @param  a, order by sort spec: asc | desc
	 *  @param  n, order by sort spec: null first | null last
	 */
	FrameBoundExpressionRange(int t = 0, bool a = true, bool n = true) :
		FrameBoundConstantRange<T>(t, a, n) {};

	/** @brief FrameBoundExpressionRange destructor
	 */
	virtual ~FrameBoundExpressionRange() {};

	/** @brief clone
	 */
	virtual FrameBound* clone()
	{ return new FrameBoundExpressionRange(*this); }

	/** @brief virtual void getBound
	 */
	// int64_t getBound(int64_t, int64_t, int64_t);

	const std::string toString() const;


protected:


	// virtual in FrameBoundRange
	int64_t getPrecedingOffset(int64_t j, int64_t i);
	int64_t getFollowingOffset(int64_t j, int64_t k);

	// validate the expression is not negative
	void validate();

};


} // namespace

#endif  // UTILS_FRAMEBOUNDRANGE_H

// vim:ts=4 sw=4: