core/sql/executor/MdamInterval.h - trafodion - Git at Google

 /**********************************************************************
 // @@@ START COPYRIGHT @@@
 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you 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.
 //
 // @@@ END COPYRIGHT @@@
 **********************************************************************/
 #ifndef MDAMINTERVAL_H
 #define MDAMINTERVAL_H
 /* -*-C++-*-
 ********************************************************************************
 *
 * File:         MdamInterval.h
 * Description:  MDAM Interval
 *
 *
 * Created:      9/11/96
 * Language:     C++
 *
 *
 ********************************************************************************
 */

 // -----------------------------------------------------------------------------

 #include "MdamEnums.h"
 #include "NABoolean.h"
 #include "MdamPoint.h"
 #include "MdamRefList.h"
 #include "FixedSizeHeapManager.h"

 // Forward references...
 class MdamEndPoint;
 class tupp;

 // *****************************************************************************
 // MdamInterval represents a range of values from beginPoint_ to endPoint_.
 // An invarient relation is that beginPoint_ <= endPoint_.  Associated with
 // an interval is a reference list.  It specifies the disjuncts the interval
 // satisfies.
 // *****************************************************************************
 class MdamInterval
 {

 friend class MdamIntervalIterator;

 public:

   // Constructor.
   // $$$$ Possibly testing only.
   inline MdamInterval(const tupp & beginTupp,
 				 const MdamEnums::MdamInclusion beginInclusion,
 				 const tupp & endTupp,
 				 const MdamEnums::MdamInclusion endInclusion,
 				 const Int32 disjunctNum,
 				 FixedSizeHeapManager & mdamRefListEntryHeap);

   // Constructor without a disjunctNum.  Building of MdamRefList is deferred.
    MdamInterval(const tupp & beginTupp,
 				 const MdamEnums::MdamInclusion beginInclusion,
 				 const tupp & endTupp,
 				 const MdamEnums::MdamInclusion endInclusion);

   // Constructor without a disjunctNum.  Building of MdamRefList is deferred.
    MdamInterval(MdamEndPoint & beginEndPoint,
 				 MdamEndPoint & endEndPoint);

   // This constructor meets the special requirements of
   // MdamIntervalList::unionSeparateDisjuncts.  These requirements are:
   //  + reverse the inclusion of endEndPoint if it is of type BEGIN, and
   //  + build a reference list.
   MdamInterval(MdamEndPoint & beginEndPoint,
 			  MdamEndPoint & endEndPoint,
 			  MdamInterval * intervalPtr0,
 			  MdamInterval * intervalPtr1,
 			  const Int32 disjunctNum,
 			  FixedSizeHeapManager & mdamRefListEntryHeap);

   // Destructor.
   ~MdamInterval();

   // Operator new.
   inline void * operator new(size_t size,
 					FixedSizeHeapManager & mdamIntervalHeap);

   // Operator new with just size_t.  This should never be called.
    void * operator new(size_t size);

   // Operator delete.  This should never be called.
    void operator delete(void *);


   // Determines if a value is contained within this interval.
   NABoolean contains(const ULng32 keyLen, const char * v)
        const;

   // Create the Reference list for an interval.  The new reference list is
   // a copy of the reference list associated with interval1Ptr.  disjunctNum
   // is inserted into the new list if the interval pointed to by interval2Ptr
   // is active.
   void createRefList(const MdamInterval * interval1Ptr,
 				const MdamInterval * interval2Ptr,
 				const Int32 disjunctNum,
 				FixedSizeHeapManager & mdamRefListEntryHeap);

   // Get function that obtains the first value in an interval.
   // The value is stored at the location specified by s.
   // If the operation is successful, the function returns true.
   // Otherwise, it returns false.  Failure can occur if the begin
   // end point is excluded and incrementing the value results
   // in an error or a value that is outside the interval.
   NABoolean getFirstValue(const ULng32 keyLen, char * s)
        const;

   // Const function to get nextMdamIntervalPtr_.
   inline MdamInterval * getNextMdamIntervalPtr() const;

   // Get function that obtains the next value in an interval.  The
   // value is stored at the location specified by s.  If the operation
   // is successful, the function returns true.  Otherwise, it returns
   // false.  Failure can occur if incrementing the value results in an
   // error or a value that is outside the interval.
   NABoolean getNextValue(const ULng32 keyLen, char * s) const;

   // Const function to get the address of the beginning or ending point.
   MdamPoint * getPointPtr
     (const MdamEnums::MdamEndPointType endPointType);

   // Function to get the address of the MdamRefList.
   inline MdamRefList * getRefListPtr();

   // This function inserts a single disjunct number into the reference list
   // associated with this MdamInterval.
   inline void insertDisjunctNum(const Int32 disjunctNum,
 				FixedSizeHeapManager & mdamRefListEntryHeap);

   // Release resources associated with this interval.
   // This is used prior to returning the interval to the free list.
   inline void release(FixedSizeHeapManager & mdamRefListEntryHeap);

   // Release reference list entries associated with this interval.
   inline void releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap);

   // Release tupp storage associated with this interval.
   inline void releaseTupps();

   // Print functions.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
   void print(const char * header = "") const;
   void printBrief() const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */

   // Mutator function to set nextMdamIntervalPtr_.
   void setNextMdamIntervalPtr(MdamInterval * nextMdamIntervalPtr);


 private:

   // MdamPoint that marks the beginning of the interval.
   MdamPoint beginPoint_;

   // MdamPoint that marks the end of the interval.
   MdamPoint endPoint_;

   // MdamRefList associated with the interval.
   MdamRefList mdamRefList_;

   // This forward pointer is used to form a singlely-linked list of intervals.
   MdamInterval * nextMdamIntervalPtr_;

 }; // class MdamInterval


 // *****************************************************************************
 // Inline member functions for class MdamInterval
 // *****************************************************************************


 // Constructor.
 inline MdamInterval::MdamInterval(const tupp & beginTupp,
                                   const MdamEnums::MdamInclusion beginInclusion,
                                   const tupp & endTupp,
                                   const MdamEnums::MdamInclusion endInclusion,
                                   const Int32 disjunctNum,
 				  FixedSizeHeapManager & mdamRefListEntryHeap)
      : beginPoint_(beginTupp, beginInclusion),
        endPoint_(endTupp, endInclusion),
        mdamRefList_(disjunctNum, mdamRefListEntryHeap),
        nextMdamIntervalPtr_(0)
 {}

 // Operator new.
 inline void * MdamInterval::operator new
   (size_t size,
    FixedSizeHeapManager & mdamIntervalHeap)
 {
   return mdamIntervalHeap.allocateElement(size);
 }


 // Function to get the address of the MdamRefList.
 inline MdamRefList * MdamInterval::getRefListPtr()
 {
   return &mdamRefList_;
 }


 // This function inserts a single disjunct number into the reference list
 // associated with this MdamInterval.
 inline void MdamInterval::insertDisjunctNum(const Int32 disjunctNum,
 			     FixedSizeHeapManager & mdamRefListEntryHeap)
 {
   mdamRefList_.insert(disjunctNum, mdamRefListEntryHeap);
 }


 // Const function to get nextMdamIntervalPtr_.
 inline MdamInterval * MdamInterval::getNextMdamIntervalPtr () const
 {
   return nextMdamIntervalPtr_;
 }


 // Release resources associated with this interval.
 // This is used prior to returning the interval to the free list.
 inline void MdamInterval::release(FixedSizeHeapManager & mdamRefListEntryHeap)
 {
   releaseTupps();
   releaseRefListEntries(mdamRefListEntryHeap);
 }


 // Release reference list entries associated with this interval.
 inline void MdamInterval::releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap)
 {
   mdamRefList_.deleteEntries(mdamRefListEntryHeap);
 }


 // Release tupp storage associated with this interval.
 inline void MdamInterval::releaseTupps()
 {
   beginPoint_.release();
   endPoint_.release();
 }

 #endif /* MDAMINTERVAL_H */
	/**********************************************************************
	// @@@ START COPYRIGHT @@@
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you 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.
	//
	// @@@ END COPYRIGHT @@@
	**********************************************************************/
	#ifndef MDAMINTERVAL_H
	#define MDAMINTERVAL_H
	/* --C++--
	********************************************************************************
	*
	* File: MdamInterval.h
	* Description: MDAM Interval
	*
	*
	* Created: 9/11/96
	* Language: C++
	*
	*
	********************************************************************************
	*/

	// -----------------------------------------------------------------------------

	#include "MdamEnums.h"
	#include "NABoolean.h"
	#include "MdamPoint.h"
	#include "MdamRefList.h"
	#include "FixedSizeHeapManager.h"

	// Forward references...
	class MdamEndPoint;
	class tupp;

	// *****************************************************************************
	// MdamInterval represents a range of values from beginPoint_ to endPoint_.
	// An invarient relation is that beginPoint_ <= endPoint_. Associated with
	// an interval is a reference list. It specifies the disjuncts the interval
	// satisfies.
	// *****************************************************************************
	class MdamInterval
	{

	friend class MdamIntervalIterator;

	public:

	// Constructor.
	// $$$$ Possibly testing only.
	inline MdamInterval(const tupp & beginTupp,
	const MdamEnums::MdamInclusion beginInclusion,
	const tupp & endTupp,
	const MdamEnums::MdamInclusion endInclusion,
	const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap);

	// Constructor without a disjunctNum. Building of MdamRefList is deferred.
	MdamInterval(const tupp & beginTupp,
	const MdamEnums::MdamInclusion beginInclusion,
	const tupp & endTupp,
	const MdamEnums::MdamInclusion endInclusion);

	// Constructor without a disjunctNum. Building of MdamRefList is deferred.
	MdamInterval(MdamEndPoint & beginEndPoint,
	MdamEndPoint & endEndPoint);

	// This constructor meets the special requirements of
	// MdamIntervalList::unionSeparateDisjuncts. These requirements are:
	// + reverse the inclusion of endEndPoint if it is of type BEGIN, and
	// + build a reference list.
	MdamInterval(MdamEndPoint & beginEndPoint,
	MdamEndPoint & endEndPoint,
	MdamInterval * intervalPtr0,
	MdamInterval * intervalPtr1,
	const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap);

	// Destructor.
	~MdamInterval();

	// Operator new.
	inline void * operator new(size_t size,
	FixedSizeHeapManager & mdamIntervalHeap);

	// Operator new with just size_t. This should never be called.
	void * operator new(size_t size);

	// Operator delete. This should never be called.
	void operator delete(void *);


	// Determines if a value is contained within this interval.
	NABoolean contains(const ULng32 keyLen, const char * v)
	const;

	// Create the Reference list for an interval. The new reference list is
	// a copy of the reference list associated with interval1Ptr. disjunctNum
	// is inserted into the new list if the interval pointed to by interval2Ptr
	// is active.
	void createRefList(const MdamInterval * interval1Ptr,
	const MdamInterval * interval2Ptr,
	const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap);

	// Get function that obtains the first value in an interval.
	// The value is stored at the location specified by s.
	// If the operation is successful, the function returns true.
	// Otherwise, it returns false. Failure can occur if the begin
	// end point is excluded and incrementing the value results
	// in an error or a value that is outside the interval.
	NABoolean getFirstValue(const ULng32 keyLen, char * s)
	const;

	// Const function to get nextMdamIntervalPtr_.
	inline MdamInterval * getNextMdamIntervalPtr() const;

	// Get function that obtains the next value in an interval. The
	// value is stored at the location specified by s. If the operation
	// is successful, the function returns true. Otherwise, it returns
	// false. Failure can occur if incrementing the value results in an
	// error or a value that is outside the interval.
	NABoolean getNextValue(const ULng32 keyLen, char * s) const;

	// Const function to get the address of the beginning or ending point.
	MdamPoint * getPointPtr
	(const MdamEnums::MdamEndPointType endPointType);

	// Function to get the address of the MdamRefList.
	inline MdamRefList * getRefListPtr();

	// This function inserts a single disjunct number into the reference list
	// associated with this MdamInterval.
	inline void insertDisjunctNum(const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap);

	// Release resources associated with this interval.
	// This is used prior to returning the interval to the free list.
	inline void release(FixedSizeHeapManager & mdamRefListEntryHeap);

	// Release reference list entries associated with this interval.
	inline void releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap);

	// Release tupp storage associated with this interval.
	inline void releaseTupps();

	// Print functions.
	#ifdef NA_MDAM_EXECUTOR_DEBUG
	void print(const char * header = "") const;
	void printBrief() const;
	#endif /* NA_MDAM_EXECUTOR_DEBUG */

	// Mutator function to set nextMdamIntervalPtr_.
	void setNextMdamIntervalPtr(MdamInterval * nextMdamIntervalPtr);


	private:

	// MdamPoint that marks the beginning of the interval.
	MdamPoint beginPoint_;

	// MdamPoint that marks the end of the interval.
	MdamPoint endPoint_;

	// MdamRefList associated with the interval.
	MdamRefList mdamRefList_;

	// This forward pointer is used to form a singlely-linked list of intervals.
	MdamInterval * nextMdamIntervalPtr_;

	}; // class MdamInterval


	// *****************************************************************************
	// Inline member functions for class MdamInterval
	// *****************************************************************************


	// Constructor.
	inline MdamInterval::MdamInterval(const tupp & beginTupp,
	const MdamEnums::MdamInclusion beginInclusion,
	const tupp & endTupp,
	const MdamEnums::MdamInclusion endInclusion,
	const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap)
	: beginPoint_(beginTupp, beginInclusion),
	endPoint_(endTupp, endInclusion),
	mdamRefList_(disjunctNum, mdamRefListEntryHeap),
	nextMdamIntervalPtr_(0)
	{}

	// Operator new.
	inline void * MdamInterval::operator new
	(size_t size,
	FixedSizeHeapManager & mdamIntervalHeap)
	{
	return mdamIntervalHeap.allocateElement(size);
	}


	// Function to get the address of the MdamRefList.
	inline MdamRefList * MdamInterval::getRefListPtr()
	{
	return &mdamRefList_;
	}


	// This function inserts a single disjunct number into the reference list
	// associated with this MdamInterval.
	inline void MdamInterval::insertDisjunctNum(const Int32 disjunctNum,
	FixedSizeHeapManager & mdamRefListEntryHeap)
	{
	mdamRefList_.insert(disjunctNum, mdamRefListEntryHeap);
	}


	// Const function to get nextMdamIntervalPtr_.
	inline MdamInterval * MdamInterval::getNextMdamIntervalPtr () const
	{
	return nextMdamIntervalPtr_;
	}


	// Release resources associated with this interval.
	// This is used prior to returning the interval to the free list.
	inline void MdamInterval::release(FixedSizeHeapManager & mdamRefListEntryHeap)
	{
	releaseTupps();
	releaseRefListEntries(mdamRefListEntryHeap);
	}


	// Release reference list entries associated with this interval.
	inline void MdamInterval::releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap)
	{
	mdamRefList_.deleteEntries(mdamRefListEntryHeap);
	}


	// Release tupp storage associated with this interval.
	inline void MdamInterval::releaseTupps()
	{
	beginPoint_.release();
	endPoint_.release();
	}

	#endif /* MDAMINTERVAL_H */