the begginning

utils/windowfunction/frameboundrange.h

@@ -0,0 +1,208 @@
+/* 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: