trafodion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ansha...@apache.org
Subject [15/30] incubator-trafodion git commit: TRAFODION-2731 CodeCleanup: Remove obsolete, legacy and unused code
Date Thu, 07 Sep 2017 01:55:09 GMT
http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/ExVPJoin.cpp
----------------------------------------------------------------------
diff --git a/core/sql/executor/ExVPJoin.cpp b/core/sql/executor/ExVPJoin.cpp
index 0de47cd..ff9caa6 100644
--- a/core/sql/executor/ExVPJoin.cpp
+++ b/core/sql/executor/ExVPJoin.cpp
@@ -43,7 +43,6 @@
 // obsolete and not used.
 // LCOV_EXCL_START
 
-NA_EIDPROC
 ex_tcb * ExVPJoinTdb::build(ex_globals * glob)
 {
   // first build the child TCBs
@@ -67,7 +66,6 @@ ex_tcb * ExVPJoinTdb::build(ex_globals * glob)
 }
 
 
-NA_EIDPROC
 ExVPJoinTcb::ExVPJoinTcb(const ExVPJoinTdb & vpjTdb,
 			 const ex_tcb ** childTcbs,
 			 ex_globals *glob)
@@ -116,7 +114,6 @@ ExVPJoinTcb::ExVPJoinTcb(const ExVPJoinTdb & vpjTdb,
   nextReqIx_ = qParent_.down->getHeadIndex();
 }
 
-NA_EIDPROC
 ExVPJoinTcb::~ExVPJoinTcb()
 {
   delete qParent_.up;
@@ -143,11 +140,9 @@ Int32 ExVPJoinTcb::numChildren() const
 
 
 
-NA_EIDPROC
 void ExVPJoinTcb::freeResources()
 {}
 
-NA_EIDPROC
 void ExVPJoinTcb::registerSubtasks()
 {
   ExScheduler *sched = getGlobals()->getScheduler();
@@ -173,7 +168,6 @@ void ExVPJoinTcb::registerSubtasks()
   exceptionEvent_ = sched->registerNonQueueSubtask(sWorkUp, this);
 }
 
-NA_EIDPROC
 short ExVPJoinTcb::work()
 {
   // The work procedures for VPJoin first pass a request from the
@@ -191,7 +185,6 @@ short ExVPJoinTcb::work()
   return WORK_OK;
 }
 
-NA_EIDPROC
 ExWorkProcRetcode ExVPJoinTcb::workDown()
 {
   // Move requests from parent down queue to child down queues.
@@ -255,7 +248,6 @@ ExWorkProcRetcode ExVPJoinTcb::workDown()
   return WORK_OK;
 }
 
-NA_EIDPROC
 ExWorkProcRetcode ExVPJoinTcb::workUp()
 {
   // Move replies from child nodes up to parent.  The replies at the
@@ -435,7 +427,6 @@ ExWorkProcRetcode ExVPJoinTcb::workUp()
     return WORK_OK;
 }
 
-NA_EIDPROC
 void ExVPJoinTcb::cancelParentRequest(ex_queue_entry * pentry, 
 				      queue_index pix)
 {
@@ -453,7 +444,6 @@ void ExVPJoinTcb::cancelParentRequest(ex_queue_entry * pentry,
     }
 }
 
-NA_EIDPROC
 ExWorkProcRetcode ExVPJoinTcb::workCancel()
 {
   // Walk through already processed down requests and cancel those
@@ -472,29 +462,23 @@ ExWorkProcRetcode ExVPJoinTcb::workCancel()
   return WORK_OK;
 }
 
-NA_EIDPROC
 short ExVPJoinTcb::sWorkDown(ex_tcb *tcb)
    { return ((ExVPJoinTcb *) tcb)->workDown(); }
-NA_EIDPROC
 short ExVPJoinTcb::sWorkUp(ex_tcb *tcb) 
    { return ((ExVPJoinTcb *) tcb)->workUp(); }
-NA_EIDPROC
 short ExVPJoinTcb::sWorkCancel(ex_tcb *tcb)
    { return ((ExVPJoinTcb *) tcb)->workCancel(); }
 
-NA_EIDPROC
 ExVPJoinPrivateState::ExVPJoinPrivateState(const ExVPJoinTcb * tcb)
 {
   init();
 }
 
-NA_EIDPROC
 ex_tcb_private_state * ExVPJoinPrivateState::allocate_new(const ex_tcb * tcb)
 {
   return new (((ex_tcb*)tcb)->getSpace()) ExVPJoinPrivateState((ExVPJoinTcb*) tcb);
 }
 
-NA_EIDPROC
 ExVPJoinPrivateState::~ExVPJoinPrivateState()
 {}
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/ExVPJoin.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/ExVPJoin.h b/core/sql/executor/ExVPJoin.h
index 1e7f156..bbc7c80 100644
--- a/core/sql/executor/ExVPJoin.h
+++ b/core/sql/executor/ExVPJoin.h
@@ -88,16 +88,16 @@ public:
   // retrieval of the virtual table function pointer of the class while
   // unpacking. An empty constructor is enough.
   // ---------------------------------------------------------------------
-  NA_EIDPROC ExVPJoinTdb()
+  ExVPJoinTdb()
   {}
 
-  NA_EIDPROC virtual ~ExVPJoinTdb()
+  virtual ~ExVPJoinTdb()
   {}
 
   // ---------------------------------------------------------------------
   // Build a TCB for this TDB. Redefined in the Executor project.
   // ---------------------------------------------------------------------
-  NA_EIDPROC virtual ex_tcb *build(ex_globals *globals);
+  virtual ex_tcb *build(ex_globals *globals);
 
 private:
   // ---------------------------------------------------------------------
@@ -136,16 +136,16 @@ class ExVPJoinTcb: public ex_tcb
 
 public:
   
-  NA_EIDPROC ExVPJoinTcb(const ExVPJoinTdb & vpjTdb, // TDB from which to build TCB
+  ExVPJoinTcb(const ExVPJoinTdb & vpjTdb, // TDB from which to build TCB
 			 const ex_tcb ** childTcbs,  // child TCBs
 			 ex_globals *glob            // globals
 			 );
         
-  NA_EIDPROC ~ExVPJoinTcb();
+  ~ExVPJoinTcb();
 
-  NA_EIDPROC void freeResources();
-  NA_EIDPROC ExWorkProcRetcode work();
-  NA_EIDPROC void registerSubtasks();
+  void freeResources();
+  ExWorkProcRetcode work();
+  void registerSubtasks();
 
   const ex_tcb* getChild(Int32 pos) const;
   ex_queue_pair  getParentQueue() const;
@@ -157,19 +157,16 @@ private:
 
   // Work methods.
   //
-  NA_EIDPROC ExWorkProcRetcode workDown();
-  NA_EIDPROC ExWorkProcRetcode workUp();
-  NA_EIDPROC ExWorkProcRetcode workCancel();
+  ExWorkProcRetcode workDown();
+  ExWorkProcRetcode workUp();
+  ExWorkProcRetcode workCancel();
 
   // Static work procedures for scheduler.
   //
-  NA_EIDPROC
   static short sWorkDown(ex_tcb *tcb);
   //                          { return ((ExVPJoinTcb *) tcb)->workDown(); }
-  NA_EIDPROC
   static short sWorkUp(ex_tcb *tcb);
   //                          { return ((ExVPJoinTcb *) tcb)->workUp(); }
-  NA_EIDPROC
   static short sWorkCancel(ex_tcb *tcb);
   //                          { return ((ExVPJoinTcb *) tcb)->workCancel(); }
 
@@ -178,7 +175,7 @@ private:
   // Cancel request from parent.  pReq points to (parent down)
   // queue entry containing the request, and pIx identifies the 
   // queue index of this entry.
-  NA_EIDPROC void cancelParentRequest(ex_queue_entry *pReq, queue_index pIx);
+  void cancelParentRequest(ex_queue_entry *pReq, queue_index pIx);
 
   // Event by which we can tell the scheduler to call workUp().  This
   // is sometimes necessary to handle cancelled requests correctly.
@@ -205,9 +202,9 @@ class ExVPJoinPrivateState : public ex_tcb_private_state
   friend class ExVPJoinTcb;
 
 public:
-  NA_EIDPROC ExVPJoinPrivateState(const ExVPJoinTcb * tcb);
-  NA_EIDPROC ex_tcb_private_state * allocate_new(const ex_tcb * tcb);
-  NA_EIDPROC ~ExVPJoinPrivateState();
+  ExVPJoinPrivateState(const ExVPJoinTcb * tcb);
+  ex_tcb_private_state * allocate_new(const ex_tcb * tcb);
+  ~ExVPJoinPrivateState();
 
 private:
   inline void init();

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/Ex_esp_msg.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/Ex_esp_msg.h b/core/sql/executor/Ex_esp_msg.h
index 4b7b924..aea180f 100644
--- a/core/sql/executor/Ex_esp_msg.h
+++ b/core/sql/executor/Ex_esp_msg.h
@@ -1132,14 +1132,8 @@ public:
                                             { return f_.fragmentLength_; }
   inline char *getFragment() const                   { return fragment_; }
   inline Lng32 getNumTemps() const                 { return f_.numTemps_; }
-#ifndef NA_TMFNOTYETSUPPORTED
   inline NABoolean getNeedsTransaction() const
                               { return (NABoolean) f_.needsTransaction_; }
-#else
-  inline NABoolean getNeedsTransaction() const
-                              { return (NABoolean) 0; }
-
-#endif
   inline NABoolean getDisplayInGui() const
                                   { return (NABoolean) f_.displayInGui_; }
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/FixedSizeHeapElement.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/FixedSizeHeapElement.h b/core/sql/executor/FixedSizeHeapElement.h
index d14a41e..d944976 100644
--- a/core/sql/executor/FixedSizeHeapElement.h
+++ b/core/sql/executor/FixedSizeHeapElement.h
@@ -58,41 +58,41 @@ class FixedSizeHeapElement
 public:
 
   // Constructor.
-  NA_EIDPROC FixedSizeHeapElement
+  FixedSizeHeapElement
     (FixedSizeHeapElement * nextElementPtr = 0)
     : nextElementPtr_(nextElementPtr) {}
 
 
   // Destructor.
-  NA_EIDPROC inline ~FixedSizeHeapElement() {}
+  inline ~FixedSizeHeapElement() {}
 
   // Operator new.
-  NA_EIDPROC inline void * operator new(size_t, char * ptr);
+  inline void * operator new(size_t, char * ptr);
 
   // Operator new. This should never be called.
-  NA_EIDPROC void * operator new(size_t)
+  void * operator new(size_t)
   {
   ex_assert(0,"FixedSizeHeapElement::operator new(size_t) called.");
   return 0;
   }
 
   // Operator delete.  This should never be called.
-  NA_EIDPROC void operator delete(void *)
+  void operator delete(void *)
   {
   ex_assert(0,"FixedSizeHeapElement::operator delete(void *) called.");
   }
 
 
   // Get function for nextElementPtr_.
-  NA_EIDPROC inline FixedSizeHeapElement * getNextElementPtr() const;
+  inline FixedSizeHeapElement * getNextElementPtr() const;
 
   // Print the status of the element.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC inline void print(const char * header = "") const;
+  inline void print(const char * header = "") const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
   // Set function for nextElementPtr_.
-  NA_EIDPROC inline void setNextElementPtr
+  inline void setNextElementPtr
     (FixedSizeHeapElement * nextElementPtr);
 
 private:
@@ -110,7 +110,7 @@ private:
 
 
 // Operator new.
-NA_EIDPROC inline void * FixedSizeHeapElement::operator new(size_t, char * ptr)
+inline void * FixedSizeHeapElement::operator new(size_t, char * ptr)
 {
   return (void *)ptr;  // $$$$ is the cast necessary?
 }

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/FixedSizeHeapManager.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/FixedSizeHeapManager.h b/core/sql/executor/FixedSizeHeapManager.h
index 7e22933..dbf5d59 100644
--- a/core/sql/executor/FixedSizeHeapManager.h
+++ b/core/sql/executor/FixedSizeHeapManager.h
@@ -63,37 +63,37 @@ friend class FixedSizeHeapManagerBlock;
 public:
 
   // Constructor.
-  NA_EIDPROC FixedSizeHeapManager(const size_t elementSize,
+  FixedSizeHeapManager(const size_t elementSize,
 				  const Lng32 numberOfElements);
 
   // Destructor.
-  NA_EIDPROC  ~FixedSizeHeapManager();
+   ~FixedSizeHeapManager();
 
   // Obtains the memory for the heap.  Returns 0 if successful and an
   // ExeErrorCode if not successful.  Builds the free list.
-  NA_EIDPROC ExeErrorCode acquireHeapMemory(NAMemory * defaultHeapPtr);
+  ExeErrorCode acquireHeapMemory(NAMemory * defaultHeapPtr);
 
   // Allocate an element on the heap.
-  NA_EIDPROC void * allocateElement(size_t size);
+  void * allocateElement(size_t size);
 
   // Returns true if the heap memory has been acquired.  Otherwise, returns
   // false.
-  NA_EIDPROC NABoolean heapMemoryAcquired() const;
+  NABoolean heapMemoryAcquired() const;
 
   // Print the status of the heap.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC void print(const char * header = "") const;
+  void print(const char * header = "") const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
   // Release an element from the heap and return the space to the free list.
-  NA_EIDPROC inline void releaseElement(void * elementPtr);
+  inline void releaseElement(void * elementPtr);
 
   // Release heap memory.
-  NA_EIDPROC void releaseHeapMemory();
+  void releaseHeapMemory();
 
   // Returns true if there is space available for an element on the heap.
   // Retruns false if the heap is full or memory not acquired.
-  NA_EIDPROC inline NABoolean elementSpaceAvailable() const;
+  inline NABoolean elementSpaceAvailable() const;
 
 
 private:
@@ -120,7 +120,7 @@ private:
   Lng32 sizeBlockRounded_;
 
   // Copy constructor disallowed.
-  NA_EIDPROC inline FixedSizeHeapManager(const FixedSizeHeapManager &);
+  inline FixedSizeHeapManager(const FixedSizeHeapManager &);
 
 }; // class FixedSizeHeapManager
 
@@ -171,19 +171,19 @@ class FixedSizeHeapManagerBlock
 public:
 
   // Constructor.
-  NA_EIDPROC FixedSizeHeapManagerBlock(FixedSizeHeapManager & fixedSizeHeapManagerRef,
+  FixedSizeHeapManagerBlock(FixedSizeHeapManager & fixedSizeHeapManagerRef,
                                        const Lng32 numberOfElements,
                                        const size_t rawMemorySize);
 
   // Destructor.
-  NA_EIDPROC inline ~FixedSizeHeapManagerBlock();
+  inline ~FixedSizeHeapManagerBlock();
 
   // Operator new.
-  NA_EIDPROC inline void * operator new(size_t, char * ptr);
+  inline void * operator new(size_t, char * ptr);
 
 
   // Get function for nextBlockPtr_.
-  NA_EIDPROC inline FixedSizeHeapManagerBlock * getNextBlockPtr();
+  inline FixedSizeHeapManagerBlock * getNextBlockPtr();
 
 
 private:
@@ -205,7 +205,7 @@ private:
 
   // Print function.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC void print(const char * header = "") const;
+  void print(const char * header = "") const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
 }; // class FixedSizeHeapManagerBlock

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamEndPoint.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamEndPoint.h b/core/sql/executor/MdamEndPoint.h
index ba3dc7b..51285a9 100644
--- a/core/sql/executor/MdamEndPoint.h
+++ b/core/sql/executor/MdamEndPoint.h
@@ -65,20 +65,20 @@ class MdamEndPoint
 public:
   
   // Default constructor.
-  NA_EIDPROC MdamEndPoint();
+  MdamEndPoint();
 
   // This constructor is passed a pointer to the interval from which the
   // MdamPoint is taken.  Point type is also passed to specify which of the
   // two points to use.
-  NA_EIDPROC MdamEndPoint(MdamInterval * intervalPtr,
+  MdamEndPoint(MdamInterval * intervalPtr,
 	                  MdamEnums::MdamEndPointType endPointType,
 	                  const Int32 logicalIntervalListNumber);
 
   // Destructor.
-  NA_EIDPROC ~MdamEndPoint() {}
+  ~MdamEndPoint() {}
 
   // Adjust the interval pointer to track the active reference list.
-  NA_EIDPROC void adjustIntervalPtr(MdamInterval * & intervalPtr,
+  void adjustIntervalPtr(MdamInterval * & intervalPtr,
                                     const Int32 logicalIntervalListNumber) const;
 
   // Assign intervalPtr[1] in this to the corresponding value in other.
@@ -86,48 +86,48 @@ public:
   // represents points from both interval lists.  intervalPtr is the
   // only data member that needs to be transferred.  All others are
   // equal or the points wouldn't have been treated as duplicates.
-  NA_EIDPROC inline void assignIntervalPtr1(const MdamEndPoint * other);
+  inline void assignIntervalPtr1(const MdamEndPoint * other);
 
   // Determine if the point is a begin endpoint.  
-  NA_EIDPROC inline NABoolean begin() const;
+  inline NABoolean begin() const;
 
   // Compare two endpoints.  The function determines if the endpoint pointed
   // to by this is {less than | equal to | greater than} the endpoint pointed
   // to by other.
-  NA_EIDPROC MdamEnums::MdamOrder compare
+  MdamEnums::MdamOrder compare
       (const MdamEndPoint * other, const ULng32 keyLen) const;
 
   // Determine if the point is a end endpoint.  
-  NA_EIDPROC inline NABoolean end() const;
+  inline NABoolean end() const;
 
   // Determine if the point exists.  
-  NA_EIDPROC inline NABoolean exists() const;
+  inline NABoolean exists() const;
 
   // Get function for inclusion.
-  NA_EIDPROC inline MdamEnums::MdamInclusion getInclusion();
+  inline MdamEnums::MdamInclusion getInclusion();
 
   // Get function for pointPtr_.
-  NA_EIDPROC inline const MdamPoint * getPointPtr() const;
+  inline const MdamPoint * getPointPtr() const;
 
   // If an interval were to be formed using this MdamEndPoint as the end endpoint
   // and previousEndPoint MdamEndPoint as the begin endpoint, this function determines
   // if the resulting interval would be empty.
-  NA_EIDPROC NABoolean givesNonEmptyInterval
+  NABoolean givesNonEmptyInterval
     (const MdamEndPoint * previousEndPoint, const ULng32 keyLen) const;
 
   // Print function.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC void print(const char * header = "") const;
+  void print(const char * header = "") const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
   // Reset an endpoint to its newly-constructed state.
-  NA_EIDPROC void reset();
+  void reset();
 
   // Reverse inclusion.
-  NA_EIDPROC void reverseInclusion();
+  void reverseInclusion();
 
   // Set member data items to reflect the specified endpoint.
-  NA_EIDPROC void set(MdamInterval * intervalPtr,
+  void set(MdamInterval * intervalPtr,
 	              MdamEnums::MdamEndPointType endPointType,
 	              const Int32 logicalIntervalListNumber);
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamInterval.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamInterval.h b/core/sql/executor/MdamInterval.h
index c807b4a..7d3d73e 100644
--- a/core/sql/executor/MdamInterval.h
+++ b/core/sql/executor/MdamInterval.h
@@ -63,7 +63,7 @@ public:
 
   // Constructor.
   // $$$$ Possibly testing only.
-  NA_EIDPROC inline MdamInterval(const tupp & beginTupp,
+  inline MdamInterval(const tupp & beginTupp,
 				 const MdamEnums::MdamInclusion beginInclusion,
 				 const tupp & endTupp,
 				 const MdamEnums::MdamInclusion endInclusion,
@@ -71,20 +71,20 @@ public:
 				 FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Constructor without a disjunctNum.  Building of MdamRefList is deferred.
-  NA_EIDPROC  MdamInterval(const tupp & beginTupp,
+   MdamInterval(const tupp & beginTupp,
 				 const MdamEnums::MdamInclusion beginInclusion,
 				 const tupp & endTupp,
 				 const MdamEnums::MdamInclusion endInclusion);
 
   // Constructor without a disjunctNum.  Building of MdamRefList is deferred.
-  NA_EIDPROC  MdamInterval(MdamEndPoint & beginEndPoint,
+   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.
-  NA_EIDPROC MdamInterval(MdamEndPoint & beginEndPoint,
+  MdamInterval(MdamEndPoint & beginEndPoint,
 			  MdamEndPoint & endEndPoint,
 			  MdamInterval * intervalPtr0,
 			  MdamInterval * intervalPtr1,
@@ -92,28 +92,28 @@ public:
 			  FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Destructor.
-  NA_EIDPROC ~MdamInterval();
+  ~MdamInterval();
 
   // Operator new.
-  NA_EIDPROC inline void * operator new(size_t size,
+  inline void * operator new(size_t size,
 					FixedSizeHeapManager & mdamIntervalHeap);
 
   // Operator new with just size_t.  This should never be called.
-  NA_EIDPROC  void * operator new(size_t size);
+   void * operator new(size_t size);
 
   // Operator delete.  This should never be called.
-  NA_EIDPROC  void operator delete(void *);
+   void operator delete(void *);
 
 
   // Determines if a value is contained within this interval.
-  NA_EIDPROC NABoolean contains(const ULng32 keyLen, const char * v)
+  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.
-  NA_EIDPROC void createRefList(const MdamInterval * interval1Ptr,
+  void createRefList(const MdamInterval * interval1Ptr,
 				const MdamInterval * interval2Ptr,
 				const Int32 disjunctNum,
 				FixedSizeHeapManager & mdamRefListEntryHeap);
@@ -124,49 +124,49 @@ public:
   // 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.
-  NA_EIDPROC NABoolean getFirstValue(const ULng32 keyLen, char * s)
+  NABoolean getFirstValue(const ULng32 keyLen, char * s)
        const;
 
   // Const function to get nextMdamIntervalPtr_.
-  NA_EIDPROC inline MdamInterval * getNextMdamIntervalPtr() const;
+  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.
-  NA_EIDPROC NABoolean getNextValue(const ULng32 keyLen, char * s) const;
+  NABoolean getNextValue(const ULng32 keyLen, char * s) const;
 
   // Const function to get the address of the beginning or ending point.
-  NA_EIDPROC MdamPoint * getPointPtr
+  MdamPoint * getPointPtr
     (const MdamEnums::MdamEndPointType endPointType);
 
   // Function to get the address of the MdamRefList.
-  NA_EIDPROC inline MdamRefList * getRefListPtr();
+  inline MdamRefList * getRefListPtr();
 
   // This function inserts a single disjunct number into the reference list
   // associated with this MdamInterval.
-  NA_EIDPROC inline void insertDisjunctNum(const Int32 disjunctNum,
+  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.
-  NA_EIDPROC inline void release(FixedSizeHeapManager & mdamRefListEntryHeap);
+  inline void release(FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Release reference list entries associated with this interval.
-  NA_EIDPROC inline void releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap);
+  inline void releaseRefListEntries(FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Release tupp storage associated with this interval.
-  NA_EIDPROC inline void releaseTupps();
+  inline void releaseTupps();
 
   // Print functions.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC void print(const char * header = "") const;
-  NA_EIDPROC void printBrief() const;
+  void print(const char * header = "") const;
+  void printBrief() const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
   // Mutator function to set nextMdamIntervalPtr_.
-  NA_EIDPROC void setNextMdamIntervalPtr(MdamInterval * nextMdamIntervalPtr);
+  void setNextMdamIntervalPtr(MdamInterval * nextMdamIntervalPtr);
 
 
 private:

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamIntervalIterator.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamIntervalIterator.h b/core/sql/executor/MdamIntervalIterator.h
index 41f49f4..bf55859 100644
--- a/core/sql/executor/MdamIntervalIterator.h
+++ b/core/sql/executor/MdamIntervalIterator.h
@@ -62,14 +62,14 @@ class MdamIntervalIterator
 public:
 
   // Constructor.
-  NA_EIDPROC MdamIntervalIterator(const MdamIntervalList * intervalListPtr,
+  MdamIntervalIterator(const MdamIntervalList * intervalListPtr,
 					 const Int32 logicalIntervalListNumber);
 
   // Destructor.
-  NA_EIDPROC ~MdamIntervalIterator();
+  ~MdamIntervalIterator();
 
   // Iteration operator returns the next endpoint on each call.
-  NA_EIDPROC NABoolean operator()(MdamEndPoint & mdamEndPoint);
+  NABoolean operator()(MdamEndPoint & mdamEndPoint);
 
 private:
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamIntervalList.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamIntervalList.h b/core/sql/executor/MdamIntervalList.h
index 11a71a6..41ab088 100644
--- a/core/sql/executor/MdamIntervalList.h
+++ b/core/sql/executor/MdamIntervalList.h
@@ -74,47 +74,47 @@ public:
 
   // Default constructor creates an empty list.
   #if defined ( NA_MDAM_EXECUTOR_DEBUG_ILTF )
-  NA_EIDPROC MdamIntervalList(const Lng32 callerTag = -1);
+  MdamIntervalList(const Lng32 callerTag = -1);
   #else
-  NA_EIDPROC  MdamIntervalList();
+   MdamIntervalList();
   #endif /* NA_MDAM_EXECUTOR_DEBUG_ILTF */
 
   // Destructor.
-  NA_EIDPROC ~MdamIntervalList();
+  ~MdamIntervalList();
 
   // Appends an MdamInterval onto an MdamIntervalList.  Warning: caller
   // must ensure that the new interval is disjoint and in order.  No
   // integrity checks are performed.
-  NA_EIDPROC MdamIntervalList & append(MdamInterval * interval);
+  MdamIntervalList & append(MdamInterval * interval);
 
   #if defined ( NA_MDAM_EXECUTOR_DEBUG_ILTF )
-  NA_EIDPROC Lng32 countIntervals() const;
+  Lng32 countIntervals() const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG_ILTF */
 
   // Delete all intervals in the list.
-  NA_EIDPROC void deleteAllIntervals(FixedSizeHeapManager & mdamIntervalHeap,
+  void deleteAllIntervals(FixedSizeHeapManager & mdamIntervalHeap,
                                      FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // This function inserts a single disjunct number into the reference list
   // associated with each MdamInterval on the MdamIntervalList.
-  NA_EIDPROC void insertDisjunctNum(const Int32 disjunctNum,
+  void insertDisjunctNum(const Int32 disjunctNum,
                               FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Performs an intersect operation on two interval lists to produce a
   // result list.  The this list and the otherList are inputs to the
   // intersect operation.  The result replaces the this list.  The
   // original interval list entries for the this list are deleted.
-  NA_EIDPROC MdamIntervalList & intersect
+  MdamIntervalList & intersect
     (const MdamIntervalList & otherList,
      const ULng32 keyLen,
      FixedSizeHeapManager & mdamIntervalHeap,
      FixedSizeHeapManager & mdamRefListEntryHeap);
 
   // Determine if an interval list is empty.
-  NA_EIDPROC inline NABoolean isEmpty() const;
+  inline NABoolean isEmpty() const;
 
   #if defined ( NA_MDAM_EXECUTOR_DEBUG_ILTF )
-  NA_EIDPROC void logEvent(const Lng32 functionId,
+  void logEvent(const Lng32 functionId,
                            const Lng32 intervalCount = 0,
                            const Int64 otherListId = -1,
                            const Lng32 callerTag = -1) const;
@@ -122,8 +122,8 @@ public:
 
   // Print functions.
   #if defined ( NA_MDAM_EXECUTOR_DEBUG )
-  NA_EIDPROC void print(const char * header = "") const;
-  NA_EIDPROC void printBrief() const;
+  void print(const char * header = "") const;
+  void printBrief() const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
   // Performs an union operation on two interval lists to produce a
@@ -131,7 +131,7 @@ public:
   // with them.  The this list and the otherList are inputs to the
   // union operation.  The result replaces the this list.  The
   // original interval list entries for this list are deleted.
-  NA_EIDPROC MdamIntervalList & unionSameDisjunct
+  MdamIntervalList & unionSameDisjunct
     (const MdamIntervalList & otherList,
      const ULng32 keyLen,
      FixedSizeHeapManager & mdamIntervalHeap,
@@ -144,7 +144,7 @@ public:
   // instead.  The this list and the otherList are inputs to the
   // intersect operation.  The result replaces the this list.  The
   // original interval list entries for the this list are deleted.
-  NA_EIDPROC MdamIntervalList & unionSeparateDisjuncts
+  MdamIntervalList & unionSeparateDisjuncts
     (const MdamIntervalList & otherList,
      const Int32 disjunctNum,
      const ULng32 keyLen,
@@ -162,7 +162,7 @@ private:
 
   // Give all intervals from this list and put them in otherList.
   // this list becomes empty.
-  NA_EIDPROC void giveAllIntervals(MdamIntervalList & otherList);
+  void giveAllIntervals(MdamIntervalList & otherList);
 
   #if defined ( NA_MDAM_EXECUTOR_DEBUG_ILTF )
   const Int64 intervalListId_;

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamIntervalListIterator.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamIntervalListIterator.h b/core/sql/executor/MdamIntervalListIterator.h
index 12a99b1..08ceffd 100644
--- a/core/sql/executor/MdamIntervalListIterator.h
+++ b/core/sql/executor/MdamIntervalListIterator.h
@@ -55,21 +55,21 @@ class MdamIntervalListIterator
 public:
 
   // Constructor.
-  NA_EIDPROC MdamIntervalListIterator
+  MdamIntervalListIterator
     (const MdamIntervalList & intervalListRef)
            : intervalListRef_(intervalListRef),
            intervalPtr_(intervalListRef.firstIntervalPtr_)
   { }
 
   // Destructor.
-  NA_EIDPROC ~MdamIntervalListIterator() {}
+  ~MdamIntervalListIterator() {}
 
   // Iteration operator returns a pointer to the next interval on each call.
   // It is safe to use this operator even if the intervals are being deleted.
-  NA_EIDPROC inline MdamInterval * operator()();
+  inline MdamInterval * operator()();
 
   // This function resets the iterator to the beginning of the list.
-  NA_EIDPROC inline void init();
+  inline void init();
 
 
 private:

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamIntervalListMerger.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamIntervalListMerger.h b/core/sql/executor/MdamIntervalListMerger.h
index 1e62158..16017d2 100644
--- a/core/sql/executor/MdamIntervalListMerger.h
+++ b/core/sql/executor/MdamIntervalListMerger.h
@@ -62,7 +62,7 @@ class MdamIntervalListMerger
 public:
 
   // Constructor.
-  NA_EIDPROC MdamIntervalListMerger
+  MdamIntervalListMerger
     (const MdamIntervalList * intervalListPtr0,
      const MdamIntervalList * intervalListPtr1,
      const ULng32 keyLen)
@@ -81,16 +81,16 @@ public:
 
 
   // Destructor.
-  NA_EIDPROC ~MdamIntervalListMerger();
+  ~MdamIntervalListMerger();
 
   // Iteration operator returns the next endpoint on each call.
-  NA_EIDPROC NABoolean operator()(MdamEndPoint & mdamEndPoint);
+  NABoolean operator()(MdamEndPoint & mdamEndPoint);
 
   // Get the number of active intervals for the most recent iteration call.
-  NA_EIDPROC inline Int32 getActiveIntervals() const;
+  inline Int32 getActiveIntervals() const;
 
   // Get the number of active intervals for the previous iteration call.
-  NA_EIDPROC inline Int32 getPreviousActiveIntervals() const;
+  inline Int32 getPreviousActiveIntervals() const;
 
 private:
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamPoint.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamPoint.h b/core/sql/executor/MdamPoint.h
index 2dcdf0e..815cd06 100644
--- a/core/sql/executor/MdamPoint.h
+++ b/core/sql/executor/MdamPoint.h
@@ -62,45 +62,45 @@ class MdamPoint
 public:
   
   // Constructor that accepts tupp and inclusion.
-  NA_EIDPROC MdamPoint(const tupp & tupp,
+  MdamPoint(const tupp & tupp,
 	    const MdamEnums::MdamInclusion inclusion);
 
   // Constructor that accepts an MdamEndPoint.
-  NA_EIDPROC MdamPoint(MdamEndPoint & endPoint);
+  MdamPoint(MdamEndPoint & endPoint);
 
   // Determine if v could be within an interval for which this MdamPoint
   // is the begin endpoint.
-  NA_EIDPROC NABoolean beginContains
+  NABoolean beginContains
     (const ULng32 keyLen, const char * v) const;
 
   // Compare function.
-  NA_EIDPROC MdamEnums::MdamOrder compare(const MdamPoint * other,
+  MdamEnums::MdamOrder compare(const MdamPoint * other,
 					  const ULng32 keyLen) const;
 
   // Determine if v could be within an interval for which this MdamPoint
   // is the end endpoint.
-  NA_EIDPROC NABoolean endContains
+  NABoolean endContains
     (const ULng32 keyLen, const char * v) const;
 
   // Get function for data pointer.
-  NA_EIDPROC inline char * getDataPointer() const;
+  inline char * getDataPointer() const;
 
   // Get function for inclusion_.
-  NA_EIDPROC MdamEnums::MdamInclusion getInclusion() const;
+  MdamEnums::MdamInclusion getInclusion() const;
 
   // Determine if the MdamPoint is included.
-  NA_EIDPROC NABoolean included() const;
+  NABoolean included() const;
 
   // Reverse inclusion.
-  NA_EIDPROC void reverseInclusion();
+  void reverseInclusion();
 
   // Release tupp storage
-  NA_EIDPROC inline void release();
+  inline void release();
 
   // Print functions.
   #ifdef NA_MDAM_EXECUTOR_DEBUG
-  NA_EIDPROC void print(const char * header = "") const;
-  NA_EIDPROC void printBrief() const;
+  void print(const char * header = "") const;
+  void printBrief() const;
   #endif /* NA_MDAM_EXECUTOR_DEBUG */
   
 private:

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamRefList.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamRefList.h b/core/sql/executor/MdamRefList.h
index d947b75..cb2028c 100644
--- a/core/sql/executor/MdamRefList.h
+++ b/core/sql/executor/MdamRefList.h
@@ -66,63 +66,63 @@ class MdamRefList
   public:
 
     // Default constructor.  Creates an empty list.
-    NA_EIDPROC MdamRefList() : lastEntryPtr_(0) {}
+    MdamRefList() : lastEntryPtr_(0) {}
 
     // Constructor.  Creates a list with one entry.
-    NA_EIDPROC inline MdamRefList(const Int32 disjunctNum,
+    inline MdamRefList(const Int32 disjunctNum,
 				  FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Copy constructor is not supported.
 
     // Destructor.
-    NA_EIDPROC ~MdamRefList();
+    ~MdamRefList();
 
     // Assignment operator is not supported.
 
 // LCOV_EXCL_START
 // this operator was defined for completeness but is not currently used
     // Test for equality.
-    NA_EIDPROC NABoolean operator==(const MdamRefList & otherList) const;
+    NABoolean operator==(const MdamRefList & otherList) const;
 // LCOV_EXCL_STOP
 // end of excluding this equal operator from coverage checking
 
     // Copy the entries from one reference list to another.
     // Source list is otherList.  Target list is this list.
-    NA_EIDPROC void copyEntries(const MdamRefList & otherList,
+    void copyEntries(const MdamRefList & otherList,
 				FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Delete all reference list entries.
-    NA_EIDPROC void deleteEntries(FixedSizeHeapManager & mdamRefListEntryHeap);
+    void deleteEntries(FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Insert an entry into the reference list.
-    NA_EIDPROC MdamRefList & insert(const Int32 disjunctNum,
+    MdamRefList & insert(const Int32 disjunctNum,
 				    FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Calculate the intersection of two reference lists.
-    NA_EIDPROC void intersect(const MdamRefList & refList0Ref,
+    void intersect(const MdamRefList & refList0Ref,
 			      const MdamRefList & refList1Ref,
 			      FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Determine if the intersection of two reference lists is empty.
-    NA_EIDPROC NABoolean intersectEmpty(const MdamRefList & otherList);
+    NABoolean intersectEmpty(const MdamRefList & otherList);
 
 
     // Determine if the intersection of three reference lists (this, refList1
     // and refList2) is empty.
-    NA_EIDPROC NABoolean intersectEmpty(const MdamRefList & refList1,
+    NABoolean intersectEmpty(const MdamRefList & refList1,
 					const MdamRefList & refList2);
 
     // Determine if the list is empty.
-    NA_EIDPROC inline NABoolean isEmpty() const;
+    inline NABoolean isEmpty() const;
 
     // Print functions.
     #ifdef NA_MDAM_EXECUTOR_DEBUG
-    NA_EIDPROC void print(const char * header = "") const;
-    NA_EIDPROC void printBrief() const;
+    void print(const char * header = "") const;
+    void printBrief() const;
     #endif /* NA_MDAM_EXECUTOR_DEBUG */
 
     // Calculate the union of two reference lists.
-    NA_EIDPROC void unionx(const MdamRefList & refList0Ref,
+    void unionx(const MdamRefList & refList0Ref,
 			   const MdamRefList & refList1Ref,
 			   FixedSizeHeapManager & mdamRefListEntryHeap);
 
@@ -132,7 +132,7 @@ private:
     MdamRefListEntry * lastEntryPtr_;
 
     // Assignment operator is not supported.
-    NA_EIDPROC MdamRefList & operator=(const MdamRefList & otherList);
+    MdamRefList & operator=(const MdamRefList & otherList);
 
 
 };  // class MdamRefList
@@ -153,7 +153,7 @@ inline MdamRefList::MdamRefList(const Int32 disjunctNum,
 // LCOV_EXCL_START
 // this method is only called in the destruct, see MdamRefList.cpp for reason
 // Determine if the list is empty.
-NA_EIDPROC inline NABoolean MdamRefList::isEmpty() const
+inline NABoolean MdamRefList::isEmpty() const
 {
   return lastEntryPtr_ == 0;
 }

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamRefListEntry.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamRefListEntry.h b/core/sql/executor/MdamRefListEntry.h
index 2299b3a..1841af6 100644
--- a/core/sql/executor/MdamRefListEntry.h
+++ b/core/sql/executor/MdamRefListEntry.h
@@ -54,7 +54,7 @@ class MdamRefListEntry
     // Constructor for use on an empty list.
     // nextEntryPtr_ is set to point to the newly-created node to begin a
     // circularly-linked list.
-    NA_EIDPROC MdamRefListEntry(const Int32 disjunctNum)
+    MdamRefListEntry(const Int32 disjunctNum)
        :  disjunctNum_(disjunctNum)  /* NT_PORT , nextEntryPtr_(this) */
     {
 	    nextEntryPtr_ = this;
@@ -63,7 +63,7 @@ class MdamRefListEntry
     // Constructor for use on a non-empty list.
     // The new node is inserted into the linked list following the node pointed
     // to by beforePtr.
-    NA_EIDPROC MdamRefListEntry(const Int32 disjunctNum,
+    MdamRefListEntry(const Int32 disjunctNum,
 				       MdamRefListEntry * beforePtr)
        :  disjunctNum_(disjunctNum),
        nextEntryPtr_(beforePtr->nextEntryPtr_)
@@ -72,36 +72,36 @@ class MdamRefListEntry
     }
 
     // Destructor.
-    NA_EIDPROC inline ~MdamRefListEntry();
+    inline ~MdamRefListEntry();
 
     // Operator new.
-    NA_EIDPROC inline void * operator new(size_t size,
+    inline void * operator new(size_t size,
 		FixedSizeHeapManager & mdamRefListEntryHeap);
 
     // Operator new with just size_t.  This should never be called.
-    NA_EIDPROC void * operator new(size_t size)
+    void * operator new(size_t size)
     {
     ex_assert(0,"MdamRefListEntry::operator new(size_t) called.");
     return 0;
     }
 
     // Operator delete.  This should never be called.
-    NA_EIDPROC void operator delete(void *)
+    void operator delete(void *)
     {
     ex_assert(0,"MdamRefListEntry::operator delete(void *) called.");
     }
 
 
     // Get function for disjunctNum_.
-    NA_EIDPROC inline Int32 getDisjunctNum() const;
+    inline Int32 getDisjunctNum() const;
 
     // Get function for nextEntryPtr_.
-    NA_EIDPROC inline MdamRefListEntry * getNextEntryPtr();
+    inline MdamRefListEntry * getNextEntryPtr();
 
     // This function returns beforePtr to prepare for an insertion.
     // The object for which the function is called must be the last
     // entry of a reference list.
-    NA_EIDPROC MdamRefListEntry * positionBeforePtr(const Int32 disjunctNum);
+    MdamRefListEntry * positionBeforePtr(const Int32 disjunctNum);
 
 
   private:

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/MdamRefListIterator.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/MdamRefListIterator.h b/core/sql/executor/MdamRefListIterator.h
index 428c3dc..6587eac 100644
--- a/core/sql/executor/MdamRefListIterator.h
+++ b/core/sql/executor/MdamRefListIterator.h
@@ -56,14 +56,14 @@ class MdamRefListIterator
 public:
 
   // Constructor.
-  NA_EIDPROC MdamRefListIterator(const MdamRefList * RefListPtr);
+  MdamRefListIterator(const MdamRefList * RefListPtr);
   
   // Iteration operator returns a boolean that indicates if there was or
   // was not a "next" entry and the corresponding disjunct number.
-  NA_EIDPROC NABoolean operator () (Int32 & disjunctNum_);
+  NABoolean operator () (Int32 & disjunctNum_);
 
   // Iteration operator returns a pointer to the next entry.
-  NA_EIDPROC MdamRefListEntry * operator()();
+  MdamRefListEntry * operator()();
 
 private:
 

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/UdrExeIpc.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/UdrExeIpc.h b/core/sql/executor/UdrExeIpc.h
index 97c7363..b86214b 100644
--- a/core/sql/executor/UdrExeIpc.h
+++ b/core/sql/executor/UdrExeIpc.h
@@ -56,13 +56,13 @@
 // Define UDR_DEBUG only if we are doing a debug build with the C
 // runtime library
 //
-#ifdef NA_DEBUG_C_RUNTIME
+#ifdef _DEBUG
 #ifndef UDR_DEBUG
 #define UDR_DEBUG 1
 #endif // not UDR_DEBUG
-#else  // NA_DEBUG_C_RUNTIME
+#else  // _DEBUG
 #undef UDR_DEBUG
-#endif // NA_DEBUG_C_RUNTIME else
+#endif // _DEBUG else
 
 //
 // Define a local assert macro. We define UdrExeAssert to something

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/cluster.cpp
----------------------------------------------------------------------
diff --git a/core/sql/executor/cluster.cpp b/core/sql/executor/cluster.cpp
index 8e8f1e8..a17d014 100644
--- a/core/sql/executor/cluster.cpp
+++ b/core/sql/executor/cluster.cpp
@@ -39,9 +39,7 @@
 
 // begining of regular compilation
 #include "cluster.h"
-#ifndef __EID
 #include "memorymonitor.h"
-#endif
 #include "ExStats.h"
 #include "ComResourceInfo.h"
 #include "logmxevent.h"
@@ -83,10 +81,8 @@ HashBuffer::HashBuffer (Cluster * cluster)
   
   // if we did not see pressure yet, the maximum cluster
   // size is as big as the total memory used
-#ifndef __EID
   if ( clusterDb->memMonitor_  &&  !clusterDb->sawPressure_ )
     clusterDb->maxClusterSize_ = clusterDb->memoryUsed_;
-#endif
   
   // initialize this buffer
   init(cluster);
@@ -96,7 +92,6 @@ HashBuffer::HashBuffer (Cluster * cluster)
 
 };
 
-#ifndef __EID
 // A constructor for cases when the HashBuffer is used without a
 // Cluster object.
 // Currently, this is only used by the UniqueHashJoin (ExUniqueHashJoinTcb).
@@ -167,13 +162,10 @@ HashBuffer::HashBuffer(ULng32 bufferSize,
 
 };
 
-#endif
-
 HashBufferSerial::HashBufferSerial (Cluster * cluster)
   : HashBuffer(cluster)
 {};
 
-#ifndef __EID
 // A constructor for cases when the HashBuffer is used without a
 // Cluster object.
 // Currently, this is only used by the UniqueHashJoin (ExUniqueHashJoinTcb).
@@ -187,7 +179,6 @@ HashBufferSerial::HashBufferSerial(ULng32 bufferSize,
   : HashBuffer(bufferSize, rowSize, useVariableLength, heap, rc)
 {};
 */
-#endif
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -292,15 +283,12 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
 		     Bucket * buckets,
 		     ULng32 bucketCount,
 		     ULng32 availableMemory,
-#ifndef __EID
 		     MemoryMonitor * memMonitor,
 		     short pressureThreshold,
 		     ExExeStmtGlobals * stmtGlobals,
-#endif
 		     ExeErrorCode *rc,
 		     NABoolean noOverFlow,
 		     NABoolean isPartialGroupBy,
-#ifndef __EID
 		     unsigned short minBuffersToFlush,
 		     ULng32 numInBatch,
 
@@ -321,8 +309,6 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
 		     Int32  pMemoryContingencyMB, 
 		     Float32 estimateErrorPenalty,
 		     Float32 hashMemEstInMbPerCpu,
-
-#endif
 		     ULng32 initialHashTableSize,
 		     ExOperStats * hashOperStats
 		     )
@@ -337,12 +323,10 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
     buckets_(buckets),
     bucketCount_(bucketCount),
     memoryUsed_(0),
-#ifndef __EID
     memMonitor_(memMonitor),
     pressureThreshold_(pressureThreshold),
     sawPressure_(FALSE),
     stmtGlobals_(stmtGlobals),
-#endif
     hashLoop_(FALSE),
     noOverFlow_(noOverFlow),
     isPartialGroupBy_(isPartialGroupBy),
@@ -353,7 +337,6 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
     clusterToRead_(NULL),
     clusterReturnRightRows_(NULL),
     clusterList_(NULL),
-#ifndef __EID
     tempFile_(NULL),
     minBuffersToFlush_(minBuffersToFlush),
     minNumWriteOuterBatch_((UInt16)(numInBatch ? (numInBatch/100) % 100 
@@ -390,7 +373,6 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
     totalIOCnt_(0),
     earlyOverflowStarted_(FALSE),
     bmoMaxMemThresholdMB_(0),
-#endif
     hashOperStats_(NULL),
     bmoStats_(NULL),
     initialHashTableSize_(initialHashTableSize),
@@ -417,14 +399,13 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
   // the regular statement heap. We want this in DP2. If we are not running
   // in DP2, we set up a seperate heap (see below)
   bufferHeap_ = (NAHeap*)collHeap();
-#ifndef __EID
+
   // we are not running in DP2. Setup our own bufferHeap. We want at least
   // 10 buffers in each block of this heap. Also add a few bytes to the buffer
   // size to account for some memory management overhead.
   bufferHeap_ = new(collHeap()) NAHeap("Buffer Heap",
 				       bufferHeap_,
 				       10 * ((Lng32)bufferSize_ + 20));
-#endif
 
   // These fields are used to ensure that #buckets and #hash-table-entries
   // have no common prime factors (to make even use of the hash table entries)
@@ -438,8 +419,6 @@ ClusterDB::ClusterDB(HashOperator hashOperator,
 /////////////////////////////////////////////////////////////////////////////
 
 ClusterDB::~ClusterDB() {
-#ifndef __EID
-  
   // there is no point of checking pending I/O, as either there shouldn't
   // be any pending I/O, or we should aband pending I/Os (by closing the 
   // file at delete) in case of error.
@@ -459,8 +438,6 @@ ClusterDB::~ClusterDB() {
     availableMemory_ += bufferSize_;
   };
 
-#endif
-
   while (clusterList_) {
     Cluster * p = clusterList_->next_;
     Cluster * q;
@@ -480,9 +457,6 @@ ClusterDB::~ClusterDB() {
 };
 
 /////////////////////////////////////////////////////////////////////////////
-#ifndef __EID
-
-// LCOV_EXCL_START
 // given the time it took some cluster to run phase 3, add to local stats
 void ClusterDB::updatePhase3Time(Int64 someClusterTime)
 {
@@ -493,7 +467,6 @@ void ClusterDB::updatePhase3Time(Int64 someClusterTime)
   if ( maxPhase3Time_ < someClusterTime ) maxPhase3Time_ = someClusterTime ;
   ++numClustersNoHashLoop_;
 }
-// LCOV_EXCL_STOP
 
 //////  Q U O T A  /////////
 
@@ -510,7 +483,7 @@ void ClusterDB::yieldAllMemoryQuota()
     sprintf(msg, 
 		"YIELDED ALL MEMORY ALLOWED: %u MB (%u). Unused pool %u MB",
 		memoryQuotaMB_-minMemoryQuotaMB_,
-                0, // NA_64BIT, use instance id later
+                0,
 		stmtGlobals_->unusedMemoryQuota() );
     // log an EMS event and continue
     SQLMXLoggingArea::logExecRtInfo(NULL, 0, msg, explainNodeId_);
@@ -637,7 +610,7 @@ void ClusterDB::yieldUnusedMemoryQuota(Cluster * theOFList,
 
     sprintf(msg, "%s YIELDED %d MB (%u). %s needed %u MB, unused pool %u",
 		extraBuffers == 1 ? "HJ" : "HGB", memToYieldMB, 
-		0, // NA_64BIT, use instance id later
+		0,
                 msg1, memNeededMB,
 		stmtGlobals_->unusedMemoryQuota());
 
@@ -670,8 +643,6 @@ ULng32 ClusterDB::roundUpToPrime(ULng32 noOfClusters)
   return primes[ind] ;
 }
 
-#endif
-
 /////////////////////////////////////////////////////////////////////////////
 //  Perform checks to find if memory allocation of reqSize bytes is possible
 //  Return FALSE if allocation is not possible.
@@ -683,7 +654,6 @@ ULng32 ClusterDB::roundUpToPrime(ULng32 noOfClusters)
 /////////////////////////////////////////////////////////////////////////////
 NABoolean ClusterDB::enoughMemory(ULng32 reqSize, NABoolean checkCompilerHints)
 {
-#ifndef __EID
   char msg[512]; // for logging messages  
 
   // For testing overflow only -- Simulate extreme memory conditions
@@ -721,7 +691,7 @@ NABoolean ClusterDB::enoughMemory(ULng32 reqSize, NABoolean checkCompilerHints)
       if ( doLog_ && memNeededMB > 1 ) { // LOG -- only for more than a buffer
 	sprintf(msg, 
 		    "GRABBED %u MB (%u). Memory used %u, now allowed %u MB, request size %u, unused pool %u",
-		    memNeededMB, 0, // NA_64BIT, use instance id later
+		    memNeededMB, 0,
                     memoryUsed_, 
 		    memoryQuotaMB_, reqSize,stmtGlobals_->unusedMemoryQuota() );
 	// log an EMS event and continue
@@ -981,13 +951,10 @@ NABoolean ClusterDB::enoughMemory(ULng32 reqSize, NABoolean checkCompilerHints)
 
   }  // if (memMonitor_ && memoryUsed_ >= minMemBeforePressureCheck_ )
 
-#endif // not EID
-
   // Always return TRUE, but for Partial HGB there's one more check
   return (!isPartialGroupBy_ || availableMemory_ >= reqSize);
 };
 /////////////////////////////////////////////////////////////////////////////
-#ifndef __EID
 // A superset of setClusterToRead, for an outer cluster.
 // Also allocates the global list of buffers (in the first time) and 
 // initializes the outer cluster to start reading more
@@ -1076,7 +1043,6 @@ NABoolean ClusterBitMap::testBit(ULng32 bitIndex) {
   return (NABoolean)(bitMap_[bitIndex >> 3] & bitMask);
 };
 
-#endif
 /////////////////////////////////////////////////////////////////////////////
 
 // Internal utility: Calculate memory and create a hash table
@@ -1160,13 +1126,11 @@ Cluster::Cluster(ClusterState state,
     next_(next),
     ioPending_(FALSE),
     totalClusterSize_(0),
-#ifndef __EID
     outerBitMap_(NULL),
     tempFile_(NULL),
     readHandle_(NULL),
     completeCurrentRead_(FALSE),
     buffersRead_(0),
-#endif
     hashTable_(NULL),
     rowCount_(0),
     readCount_(0),
@@ -1175,7 +1139,6 @@ Cluster::Cluster(ClusterState state,
     bufferPool_(bufferPool),
     numInMemBuffers_(0),
     scanPosition_(NULL)
-#ifndef __EID
     ,returnOverflowRows_(FALSE)
     ,batchCountDown_(clusterDb->numReadOuterBatch_)
     ,lastSqueezedBuffer_(NULL) // no buffer squeezed yet
@@ -1189,7 +1152,6 @@ Cluster::Cluster(ClusterState state,
     ,startTimePhase3_(0)
     ,keepRecentBuffer_(FALSE)
     ,flushMe_(FALSE)
-#endif
     ,defragBuffer_(NULL)
 {
       // assume success
@@ -1243,12 +1205,10 @@ Cluster::Cluster(ClusterState state,
 	if (!hashTable_) return;
       };
 
-#ifndef __EID
       // set up a unique sequence ID for this cluster to use for overflow
       maxSeqIDIndex_ = seqIDIndex_ = 0 ;
       seqID_[seqIDIndex_] = clusterDb_->generateSequenceID();
       seqID_[1] = seqID_[2] = 0 ; // 0 is an invalid seq value
-#endif
 
       if (considerBufferDefrag_)
       {
@@ -1261,13 +1221,11 @@ Cluster::Cluster(ClusterState state,
 Cluster::~Cluster() {
   releaseAllHashBuffers();
 
-#ifndef __EID
   if (outerBitMap_) {
     delete outerBitMap_;
     outerBitMap_ = NULL;
   };
   if ( readHandle_ ) delete readHandle_;
-#endif
 
   removeHashTable();
 
@@ -1302,7 +1260,6 @@ void Cluster::removeHashTable() {
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifndef __EID
 // Decide which cluster to flush: Find the FLUSHED cluster with the max
 // #buffers, and use that one if that #buffers > minimum ; else pick one of
 // the non-flushed clusters, and if none -- use the "last resort" cluster
@@ -1387,8 +1344,6 @@ void ClusterDB::chooseClusterToFlush(Cluster * lastResort)
 
 }
 
-#endif
-
 /////////////////////////////////////////////////////////////////////////////
 
 NABoolean Cluster::insert(atp_struct * newEntry,
@@ -1422,9 +1377,7 @@ NABoolean Cluster::insert(atp_struct * newEntry,
     totalClusterSize_ += clusterDb_->bufferSize_;
   };
 
-#ifndef __EID
   lastDataPointer_ = NULL; 
-#endif
 
   NABoolean defragmented = FALSE;
   // allocate space for the new row in the buffer pool
@@ -1466,7 +1419,7 @@ NABoolean Cluster::insert(atp_struct * newEntry,
           //rows are variable-- set row length
           bufferPool_->castToSerial()->setRowLength(dataPointer, rowLen);
 
-#if (defined (NA_LINUX) && defined(_DEBUG) && !defined(__EID))
+#if (defined(_DEBUG))
           char txt[] = "Cluster::insert";
           sql_buffer_pool::logDefragInfo(txt,bufferPool_->getMaxRowLength(),
                                          ROUND4(rowLen) + sizeof(HashRow),
@@ -1499,7 +1452,6 @@ NABoolean Cluster::insert(atp_struct * newEntry,
 	};
 	// reset rc in case it was set in the constructor of HashBuffer
 	*rc = EXE_OK;
-#ifndef __EID
 	// set saw pressure as we indeed can not allocate memory
 	// fix for CR 10-071012-6254
 	clusterDb_->sawPressure_ = TRUE;
@@ -1509,7 +1461,6 @@ NABoolean Cluster::insert(atp_struct * newEntry,
 	// returning partial groups
 	if (!clusterDb_->isPartialGroupBy_)
 	  clusterDb_->chooseClusterToFlush(this);
-#endif
 	return FALSE;  
       };
       
@@ -1526,10 +1477,8 @@ NABoolean Cluster::insert(atp_struct * newEntry,
       // not enough memory avaliable. Select a cluster
       // for flushing
       
-#ifndef __EID
       if (!clusterDb_->isPartialGroupBy_)
 	clusterDb_->chooseClusterToFlush(this);
-#endif
       
       return FALSE;
     };
@@ -1566,9 +1515,7 @@ NABoolean Cluster::insert(atp_struct * newEntry,
     }
   }
 
-#ifndef __EID
   lastDataPointer_ = dataPointer; // keep location of most recent row
-#endif
 
   // set the hash value in the row header
   dataPointer->setHashValueRaw(hashValue);
@@ -1593,10 +1540,8 @@ NABoolean Cluster::insert(atp_struct * newEntry,
       // if Hash-Table was resized up, then update memory use
       clusterDb_->memoryUsed_ += memAdded ; 
 
-#ifndef __EID
       // if could not create a new HT, better pick this cluster for a flush
       if ( ! memAdded ) flushMe_ = TRUE;
-#endif
     }
   }
 
@@ -1606,7 +1551,6 @@ NABoolean Cluster::insert(atp_struct * newEntry,
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifndef __EID
 // initialize the cluster's scratch file and read handler (and the clusterDB
 // global scratch file, if needed). Return TRUE if error.
 NABoolean Cluster::initScratch(ExeErrorCode * rc)
@@ -2690,8 +2634,6 @@ void Cluster::resetForHashLoop() {
   // we don't release the buffer of the outer, since we need it
 };
 
-#endif
-
 /////////////////////////////////////////////////////////////////////////////
 ExClusterStats* Cluster::getStats(CollHeap* heap) {
   ExStatsCounter hashChains;
@@ -2758,8 +2700,6 @@ ULng32 Cluster::getMemorySizeForHashTable(ULng32 entryCount)
   return (entryCount * sizeof(HashTableHeader) * 3 / 2);
 }
 
-#ifndef __EID
-
 void Cluster::updateBitMap() {
   ex_assert(outerBitMap_, "no bitmap to update");
   outerBitMap_->setBit(readCount_);
@@ -2772,7 +2712,6 @@ NABoolean Cluster::testBitMap() {
 
 
 #include "ComCextdecs.h"
-// LCOV_EXCL_START  
 void IOTimer::resetTimer()
 {
   ioStarted_ = FALSE;
@@ -2818,7 +2757,6 @@ void ClusterDB::getScratchErrorDetail(Lng32 &scratchError,
       strcpy(errorMsg, sError->getSortErrorMsg());
     }
 }
-// LCOV_EXCL_STOP
 
 // Every time totalIOCnt_ grows, update the stats for this operator
 void ClusterDB::updateIOStats()
@@ -2831,8 +2769,6 @@ void ClusterDB::updateIOStats()
       hashOperStats_->castToExHashJoinStats()->updIoSize(ioSize);
 }
 
-#endif
-
 // Every time memoryUsed_ grows, update the stats for max memory used by this operator
 void ClusterDB::updateMemoryStats()
 {

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/cluster.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/cluster.h b/core/sql/executor/cluster.h
index 8b8cd1c..7e7fa74 100644
--- a/core/sql/executor/cluster.h
+++ b/core/sql/executor/cluster.h
@@ -41,11 +41,9 @@
 #include "hash_table.h"
 #include "CommonStructs.h"
 
-#ifndef __EID
 #include "ScratchSpace.h"
 #include "ex_exe_stmt_globals.h"
 #define END_OF_BUF_LIST ((ULng32) -1)
-#endif
 
 // To be used as the limits on input size estimates by HJ, HGB
 #define MAX_INPUT_SIZE 0x200000000LL
@@ -58,9 +56,7 @@ class Bucket;
 class IOTimer;
 class ExBMOStats;
 
-#ifndef __EID
 class MemoryMonitor;
-#endif
 
 #include "HashBufferHeader.h"
 #include "ExpError.h"
@@ -78,12 +74,8 @@ class HashBufferSerial;
 class HashBuffer : public NABasicObject {
   friend class HashBufferSerial;
 public:
-NA_EIDPROC
   HashBuffer (Cluster * cluster);
 
-#ifndef __EID
-  // this is only used by Hash Join, so does not need to be in EID code
-
   // A constructor for cases when the HashBuffer is used without a
   // Cluster object.
   // Currently, this is only used by the UniqueHashJoin (ExUniqueHashJoinTcb).
@@ -94,50 +86,33 @@ NA_EIDPROC
               CollHeap *heap,
 	      ClusterDB * clusterDb,
               ExeErrorCode * rc);
-#endif
 
-NA_EIDPROC
   ~HashBuffer();
 
-NA_EIDPROC
   inline ULng32 getMaxRowLength() const;
 
-NA_EIDPROC
   inline HashBuffer * getPrev() const;
-NA_EIDPROC
   inline void setPrev(HashBuffer * prev);
 
-NA_EIDPROC
   inline HashBuffer * getNext() const;
-NA_EIDPROC
   inline void setNext(HashBuffer * next);
 
-NA_EIDPROC
   inline char * getDataPointer() const;
-NA_EIDPROC
   inline void deallocateData(CollHeap * heap) ;
-NA_EIDPROC
   inline ULng32 getRowCount() const;
-NA_EIDPROC
   inline HashBufferHeader * getHeader() const;
-NA_EIDPROC
   void init(Cluster * cluster);
-NA_EIDPROC
   inline char * getFirstRow() const;
 
   // Does this buffer contain variable length or fixed length rows.
-NA_EIDPROC
   inline NABoolean isVariableLength() const;
 
-NA_EIDPROC
   inline NABoolean considerBufferDefrag() const;
 
   // Cast this instance to a pointer to a HashBufferSerial in order to
   // use the Serial Interface
-NA_EIDPROC
   inline HashBufferSerial *castToSerial() const;
 
-NA_EIDPROC
   inline ULng32 getFreeSpace() const
 {
   return freeSpace_;
@@ -236,12 +211,8 @@ inline HashBufferSerial *HashBuffer::castToSerial() const {
 class HashBufferSerial : public HashBuffer {
 private:
   // Constuctors and Destuctor are private - They are never used.
-NA_EIDPROC
   HashBufferSerial (Cluster * cluster);
 
-#ifndef __EID
-  // this is only used by Hash Join, so does not need to be in EID code
-
   // A constructor for cases when the HashBuffer is used without a
   // Cluster object.
   // Currently, this is only used by the UniqueHashJoin (ExUniqueHashJoinTcb).
@@ -252,9 +223,6 @@ NA_EIDPROC
                     CollHeap *heap,
                     ExeErrorCode * rc);
 
-#endif
-
-NA_EIDPROC
   ~HashBufferSerial() {};
 
 public:
@@ -263,71 +231,54 @@ public:
   // order (series) from the start of the buffer to the end.  Rows cannot be
   // accessed randomly (via a row index or number) 
 
-NA_EIDPROC
   inline void setRowCount(ULng32 cnt);
   // Set rowcount to 0 and reset buffer to be empty.
-NA_EIDPROC
   inline void clearRowCount();
 
   // Methods dealing with how many rows can fit in a buffer
 
   // Get the estimated number of rows per buffer.  It is an estimate
   // since the rows can be variable length
-NA_EIDPROC
   inline ULng32 getMaxNumFullRows() const;
 
-#ifndef __EID
   // Recalculate the number of rows that can be allocated from this buffer.
   inline ULng32 getRemainingNumFullRows() const;
 
   // Is this buffer full?
   inline NABoolean notFull() const;
-#endif
 
   // Methods for accessing rows in series based on an internal cursor (currRow_)
-NA_EIDPROC
   inline void positionOnFirstRow();
   // return the next row in the buffer
-NA_EIDPROC
   inline HashRow *getCurrentRowAndAdvance();
 
 
-NA_EIDPROC
   inline HashRow *getCurrentRow();
 
   // Methods for accessing rows in series based on an external cursor (the previous row)
 
   // Return a pointer to the first row,
-NA_EIDPROC
   inline HashRow *getFirstRow() const;
   // Get the next row after 'currentRow' based on the length of currentRow
-NA_EIDPROC
   inline HashRow *getNextRow(HashRow *currentRow) const;
 
 
   // Allocate a row of size maxRowLength_ from this HashBuffer
-NA_EIDPROC
   inline HashRow *getFreeRow();
 
-NA_EIDPROC
   inline HashRow *getFreeRow(ULng32 spaceNeeded);
 
   // Resize the last row allocated from this HashBuffer
-NA_EIDPROC
   inline void resizeLastRow(ULng32 newSize, HashRow *dataPointer);
 
   // Get row length.  If varLen, get length from row. If fixed, based
   // on maxRowLength_
-NA_EIDPROC
   inline ULng32 getRowLength(HashRow *row) const;
   // Set the row length in the row.  If row is fixed length, this method does nothing
-NA_EIDPROC
   inline void setRowLength(HashRow *row, UInt32 len);
 
-NA_EIDPROC
   void print() const;
 
-NA_EIDPROC
   void fixup();
 
 
@@ -389,7 +340,6 @@ inline ULng32 HashBufferSerial::getMaxNumFullRows() const {
   return maxNumFullRowsSer_;
 };
 
-#ifndef __EID
 // Recalculate the number of rows that can be allocated from this buffer.
 inline ULng32 HashBufferSerial::getRemainingNumFullRows() const {
   return (freeSpace_ / maxRowLength_);
@@ -400,7 +350,6 @@ inline NABoolean HashBufferSerial::notFull() const
 {
   return (freeSpace_ >= maxRowLength_);
 };
-#endif
 
 // Methods for accessing rows in series based on an internal cursor (currRow_)
 inline void HashBufferSerial::positionOnFirstRow() 
@@ -558,27 +507,18 @@ inline void HashBufferSerial::setRowLength(HashRow *row, UInt32 len) {
 /////////////////////////////////////////////////////////////////////////////
 class Bucket {
 public:
-NA_EIDPROC
   Bucket();
-NA_EIDPROC
    ~Bucket() {}; // LCOV_EXCL_LINE
-NA_EIDPROC
   void init();
-NA_EIDPROC
   inline ULng32 getRowCount() const;
-NA_EIDPROC
   inline Cluster * getInnerCluster () const;
-NA_EIDPROC
   inline Cluster * getOuterCluster () const;
-NA_EIDPROC
   inline NABoolean insert (atp_struct * newEntry,
 		           ex_expr * moveExpr,
 			   SimpleHashValue hashValue,
 			   ExeErrorCode * rc,
 			   NABoolean skipMemoryCheck = FALSE);
-NA_EIDPROC
   inline void setInnerCluster (Cluster * innerCluster);
-NA_EIDPROC
   inline void setOuterCluster (Cluster * outerCluster);
 private:
   Cluster * innerCluster_;    // corresponding inner Cluster
@@ -627,7 +567,6 @@ public:
     CROSS_PRODUCT,
     SEQUENCE_OLAP // not a hash operator; but uses ClusterDB and Cluster 
   };
-NA_EIDPROC
   ClusterDB (HashOperator hashOperator,
 	     ULng32 bufferSize,
 	     atp_struct * workAtp,
@@ -638,15 +577,12 @@ NA_EIDPROC
 	     Bucket * buckets,
 	     ULng32 bucketCount,
 	     ULng32 availableMemory,
-#ifndef __EID
 	     MemoryMonitor * memMonitor,
 	     short pressureThreshold,
 	     ExExeStmtGlobals * stmtGlobals,
-#endif
 	     ExeErrorCode * rc,
 	     NABoolean noOverFlow = FALSE,
 	     NABoolean isPartialGroupBy = FALSE,
-#ifndef __EID
 	     unsigned short minBuffersToFlush = 1,
 	     ULng32 numInBatch = 0,
 
@@ -669,60 +605,37 @@ NA_EIDPROC
 	     Int32  pMemoryContingencyMB = 0, 
 	     Float32 estimateErrorPenalty = 0,
 	     Float32 hashMemEstInMbPerCpu = 0,
-
-#endif
 	     ULng32 initialHashTableSize = 0, // default not resizable
 	     ExOperStats * hashOperStats = NULL
 );
-NA_EIDPROC
   ~ClusterDB();
 
-NA_EIDPROC
   inline Cluster * getClusterList() const;
-NA_EIDPROC
   inline void setClusterList(Cluster * clusterList);
-#ifndef __EID
   inline Cluster * getClusterToFlush() const;
   inline void setClusterToFlush(Cluster * cluster);
   void setBMOMaxMemThresholdMB(UInt16 mm)
       { bmoMaxMemThresholdMB_ = mm; }
-#endif
-NA_EIDPROC
   inline Cluster * getClusterToProbe() const;
-NA_EIDPROC
   inline void setClusterToProbe(Cluster * cluster);
-NA_EIDPROC
   inline Cluster * getClusterToRead() const;
-NA_EIDPROC
   inline void setClusterToRead(Cluster * cluster);
-NA_EIDPROC
   NABoolean setOuterClusterToRead(Cluster * cluster, ExeErrorCode * rc);
-NA_EIDPROC
   inline Cluster * getClusterReturnRightRows() const;
-NA_EIDPROC
   inline void setClusterReturnRightRows(Cluster * cluster);
-NA_EIDPROC
   inline NABoolean isHashLoop() const { return hashLoop_; }
-NA_EIDPROC
   inline Int64 getMemoryHWM() const;
-NA_EIDPROC
   inline ULng32 getBufferSize() const { return bufferSize_; }
-NA_EIDPROC
   void setScratchIOVectorSize(Int16 vectorSize)
   {
     scratchIOVectorSize_ = vectorSize;
   }
-NA_EIDPROC
   Int32 getScratchIOVectorSize() { return scratchIOVectorSize_;}
-NA_EIDPROC
   void setScratchOverflowMode(ScratchOverflowMode ovMode)
   { overFlowMode_ = ovMode;}
-NA_EIDPROC
   ScratchOverflowMode getScratchOverflowMode(void)
   { return overFlowMode_;}
   
-#ifndef __EID
-
   void chooseClusterToFlush(Cluster * lastResort);
 
   HashScratchSpace *getScratch() const;
@@ -762,19 +675,13 @@ NA_EIDPROC
   
 
   static ULng32 roundUpToPrime(ULng32 noOfClusters);
-  
-#endif
 
-NA_EIDPROC
   NABoolean enoughMemory(ULng32 size, NABoolean checkCompilerHints = FALSE);  
 
 private:
 
-NA_EIDPROC
   void updateMemoryStats();
-#ifndef __EID
   void updateIOStats();
-#endif
 
   HashOperator hashOperator_;         // indicates the type of the tcb
 				      // using this clusterDB
@@ -807,21 +714,18 @@ NA_EIDPROC
   // much main memory the operator uses right now. Cluster.totalClusterSize_
   // tells us the size of a cluster!
   ExOperStats * hashOperStats_;       // stats for this hash operator
-#ifndef __EID
   ULng32 totalIOCnt_;          // total IO ( # buffers read or writen )
   MemoryMonitor * memMonitor_;        // for dynamic memory management
   short pressureThreshold_;
   NABoolean sawPressure_;             // set when we see pressure the
                                       // first time
   ExExeStmtGlobals * stmtGlobals_;    // for dynamic memory allocation
-#endif
   ULng32 maxClusterSize_;      // in bytes
   Cluster * clusterToFlush_;          // cluster which is to be flushed
   Cluster * clusterToProbe_;          // cluster which is to be probed
   Cluster * clusterToRead_;           // cluster which is to be read
   Cluster * clusterReturnRightRows_;           // cluster which is to be read
   Cluster * clusterList_;             // list of all clusters
-#ifndef __EID
   HashScratchSpace * tempFile_;           // for overflow handling
   ExSubtask *ioEventHandler_;     
   ex_tcb * callingTcb_;
@@ -854,7 +758,6 @@ NA_EIDPROC
   ULng32 bmoMaxMemThresholdMB_;
 
   NABoolean earlyOverflowStarted_;  // if o/f based on compiler hints 
-#endif
 
   // These fields are used to ensure that #buckets and #hash-table-entries
   // have no common prime factors (to make even use of the hash table entries)
@@ -889,11 +792,9 @@ inline Cluster * ClusterDB::getClusterList() const {
 inline void ClusterDB::setClusterList(Cluster * clusterList) {
   clusterList_ = clusterList;
 };
-#ifndef __EID
 inline Cluster * ClusterDB::getClusterToFlush() const {
   return clusterToFlush_;
 };
-#endif
 
 inline Cluster * ClusterDB::getClusterToProbe() const {
   return clusterToProbe_;
@@ -919,18 +820,14 @@ inline void ClusterDB::setClusterReturnRightRows(Cluster * cluster) {
   clusterReturnRightRows_ = cluster;
 };
 
-#ifndef __EID
 inline HashScratchSpace * ClusterDB::getScratch() const {
  return tempFile_;
 };
-#endif
 
 
 /////////////////////////////////////////////////////////////////////////////
 // ClusterBitMap is used for left joins with a hash loop or for right joins
 /////////////////////////////////////////////////////////////////////////////
-#ifndef __EID
-
 class ClusterBitMap : public NABasicObject {
 public:
   ClusterBitMap(ULng32 size, ExeErrorCode * rc);
@@ -942,8 +839,6 @@ private:
   char * bitMap_;           // the bitmap itself
 };
 
-#endif
-
 /////////////////////////////////////////////////////////////////////////////
 // a Cluster is the unit of overflow handling
 /////////////////////////////////////////////////////////////////////////////
@@ -959,7 +854,6 @@ public:
                       // hash table
   };
 
-NA_EIDPROC
   Cluster(ClusterState state,
 	  ClusterDB * clusterDb,
 	  Bucket * buckets,
@@ -981,20 +875,13 @@ NA_EIDPROC
 	  ExeErrorCode *rc,
 	  HashBuffer * bufferPool = NULL);     // an already existing buffer
 
-NA_EIDPROC
   ~Cluster();
 
-NA_EIDPROC
   inline ClusterState getState() const;
-NA_EIDPROC
   inline ULng32 getRowsInBuffer() const;
-NA_EIDPROC
   inline ULng32 getRowCount() const;
-NA_EIDPROC
   inline ULng32 getReadCount() const;
-NA_EIDPROC
   inline void incReadCount();
-#ifndef __EID
   inline NABoolean endOfCluster();
   inline NABoolean hasBitMap();
   void updateBitMap();
@@ -1005,24 +892,14 @@ NA_EIDPROC
   inline NABoolean returnOverflowRows() { return returnOverflowRows_; }
   inline void initializeReadPosition();
 
-#endif
-NA_EIDPROC
   inline NABoolean bitMapEnable() const;
-NA_EIDPROC
   inline NABoolean isInner() const;
-NA_EIDPROC
   inline Cluster * getNext() const;
-NA_EIDPROC
   Cluster * getOuterCluster() const { return buckets_->getOuterCluster(); };
-NA_EIDPROC
   inline void setOuterCluster(Cluster * outerCluster);
-NA_EIDPROC
   HashTable * getHashTable() const { return hashTable_; };
-NA_EIDPROC
   inline HashBuffer * getFirstBuffer() const { return bufferPool_; };
-NA_EIDPROC
   inline void setNext(Cluster * next);
-NA_EIDPROC
   void positionOnFirstRowInBuffer() 
   {    // position on the first row in main memory 
     scanPosition_ = bufferPool_;
@@ -1030,7 +907,6 @@ NA_EIDPROC
   };
 
   // remove the hash table from the cluster
-NA_EIDPROC
   void removeHashTable();
 
   // insert a new row into the cluster. If insert() was not sucessful, it
@@ -1038,14 +914,12 @@ NA_EIDPROC
   // for insert() not to be sucessful is, if we could not t allocate a
   // new buffer for this cluster. In case of a partial group by, we do not
   // flush a cluster, instead, we return the current row as a partial group.
-NA_EIDPROC
   NABoolean insert(atp_struct * newEntry,
 		   ex_expr * moveExpr,
 		   SimpleHashValue hashValue,
 		   ExeErrorCode * rc,
 		   NABoolean skipMemoryCheck = FALSE);
 
-#ifndef __EID
   void positionOnFirstRowInFirstOuterBuffer() 
   {  // position on the first row in the first outer buffer in memory 
 
@@ -1095,23 +969,18 @@ NA_EIDPROC
   Int64 startTimePhase3() { return startTimePhase3_; };
   void setStartTimePhase3(Int64 theTime) { startTimePhase3_ = theTime ; };
 
-#endif
   // set up a cluster stats entry in heap and return it
   ExClusterStats* getStats(CollHeap* heap);
 
   // release all buffers of the Cluster
-NA_EIDPROC
   void releaseAllHashBuffers();
 
   // return next row from buffer
-NA_EIDPROC
   HashRow * advance();
   
-NA_EIDPROC
   HashRow * getCurrentRow();
 
   // Report the size (in bytes) of this cluster
-NA_EIDPROC
   inline Int64 clusterSize() {return totalClusterSize_; } // total size (bytes)
 
   // Internal utility: Calculate memory and create a hash table
@@ -1120,7 +989,6 @@ NA_EIDPROC
 			      // skip mem check for HGB; it starts at min HT 
 			      NABoolean checkMemory = FALSE );
 
-  NA_EIDPROC
     inline char * getDefragBuffer()
   {
     return defragBuffer_;
@@ -1129,7 +997,6 @@ NA_EIDPROC
 
 private:
 
-#ifndef __EID
   // split a Cluster into two. Adjust buckets accordingly.
   NABoolean checkAndSplit(ExeErrorCode * rc) ;
   HashBuffer * lastSqueezedBuffer_ ; // last buffer "squeezed"
@@ -1145,7 +1012,6 @@ private:
   UInt16 batchCountDown_; // count buffers in a batch (for split only)
 
   HashBuffer * keepRecentBuffer_; // don't flush most recent (not full) buffer
-#endif
 
   // return the memory size for building a hash table of given entry count
   ULng32 getMemorySizeForHashTable(ULng32 entryCount);
@@ -1161,20 +1027,15 @@ private:
   NABoolean isInner_;
   NABoolean bitMapEnable_;
 
-#ifndef __EID
   HashScratchSpace * tempFile_;
   ClusterPassBack * readHandle_;
-#endif
 
   Cluster * next_;                        // next Cluster in list
   NABoolean ioPending_;                   // this Cluster has an I/O in flight
 
   Int64 totalClusterSize_;                // total size of this cluster (bytes)
 
-#ifndef __EID
   ClusterBitMap * outerBitMap_;
-#endif
-
   HashTable * hashTable_;
   ULng32 rowCount_;                // # of rows stored in this cluster
   ULng32 readCount_;               // for inner: number of rows read in
@@ -1188,8 +1049,6 @@ private:
   ULng32 numInMemBuffers_;         // number of in-memory buffers for this cluster
   HashBuffer * scanPosition_;             // for scanning all buffers
 
-#ifndef __EID
-
   // for concurrent writing of multiple buffers, need to know which is next
   HashBuffer * nextBufferToFlush_;
   // For OLAP - when reading buffers from overflow for "bounded following", 
@@ -1229,8 +1088,6 @@ private:
   NABoolean completeCurrentRead_ ; // synch buffers read so far 
   Int16 buffersRead_ ;
 
-#endif
-
   char * defragBuffer_;
 };
 
@@ -1260,7 +1117,6 @@ inline void Cluster::incReadCount() {
   readCount_++;
 };
 
-#ifndef __EID
 inline NABoolean Cluster::hasBitMap() {
   return (outerBitMap_ != NULL);
 };
@@ -1308,9 +1164,6 @@ inline NABoolean Cluster::IONotReady(ExeErrorCode * rc,
   return FALSE; // IO is ready
 }
 
-
-#endif
-
 inline NABoolean Cluster::bitMapEnable() const {
   return bitMapEnable_;
 };
@@ -1337,7 +1190,6 @@ inline void Cluster::setNext(Cluster * next) {
   next_ = next;
 };
 
-#ifndef __EID
 // This ClusterDB method needs to follow the reclaration of the class Cluster
 inline void ClusterDB::setClusterToFlush(Cluster * cluster) {
   clusterToFlush_ = cluster;
@@ -1347,7 +1199,6 @@ inline void ClusterDB::setClusterToFlush(Cluster * cluster) {
   // when cluster is selected explicitly -- flush all the buffers (incl. last)
   clusterToFlush_->keepRecentBuffer_ = NULL;
 };
-#endif
 
 // The Bucket::insert is just a wrapper over Cluster::insert that also
 // updates the per-Bucket rows counter
@@ -1372,16 +1223,16 @@ inline NABoolean Bucket::insert(atp_struct * newEntry,
 class IOTimer 
 {
 public:
-  NA_EIDPROC 
+  
   IOTimer () ;
 
-  NA_EIDPROC 
+  
   void resetTimer();             // re-zero the elapsed time (not needed on first use)
 
-  NA_EIDPROC 
+  
   NABoolean startTimer();        // do nothing, return FALSE is already started
 
-  NA_EIDPROC 
+  
   Int64 endTimer();              // Return elapsed time.
   
 private:

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/dfs2fe.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/dfs2fe.h b/core/sql/executor/dfs2fe.h
index 74cdade..075f74e 100644
--- a/core/sql/executor/dfs2fe.h
+++ b/core/sql/executor/dfs2fe.h
@@ -657,7 +657,6 @@ enum ExeDfs2feEnum
    , FEMOREDATA		  = dfs2fe_base + 1179
    , FESEQUENCE        = dfs2fe_base + 1180
    , FESIDETREE        = dfs2fe_base + 1181
-   , FERFORKLOCKED     = dfs2fe_base + 1182
    , FENOSQLMX         = dfs2fe_base + 1183
    , FECPUSWITCHED     = dfs2fe_base + 1184
    , FESQLMXINTERNALERR= dfs2fe_base + 1185

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/1522c8cd/core/sql/executor/dmeasql.h
----------------------------------------------------------------------
diff --git a/core/sql/executor/dmeasql.h b/core/sql/executor/dmeasql.h
index 37bcd1f..ade3632 100644
--- a/core/sql/executor/dmeasql.h
+++ b/core/sql/executor/dmeasql.h
@@ -20,70 +20,3 @@
 //
 // @@@ END COPYRIGHT @@@
 **********************************************************************/
-#ifndef _DMEASQL
-#define _DMEASQL
-
-//#pragma columns 79
-#pragma page "dmeasql.h - T9086 Measure / SQL Interface Declarations"
-
-
-//#ifndef _rosgenh_
-//#define _rosgenh_
-//#include "rosgen.h"
-//#endif  
-
-
-typedef struct SQLSTMT_CTRS_DEF {
-  char          run_unit[128] ;
-  Int32           statement_index; //indexed statement number
-  Int32           sorts;
-  Int32           recompiles;
-  Int32           lock_waits;
-  Int64         calls;
-  Int64         elapsed_busy_time;
-  Int64         records_used;
-  Int64         records_accessed;
-  Int64         disc_reads;
-  Int64         messages;
-  Int64         message_bytes;
-  Int64         elapsed_sort_time;
-  Int64         elapsed_compile_time;
-  Int32           timeouts;
-  Int32           escalations;
-  char          _filler[4];
-} SQLSTMT_CTRS_DEF;
-
-typedef struct SQLPROC_CTRS_DEF {
-  Int32    sql_obj_recompiles;
-  Int64  sql_obj_recompile_time;
-  Int32    sql_stmt_recompiles;
-  Int64  sql_stmt_recompile_time;
-  Int32    sql_newprocesses;
-  Int64  sql_newprocess_time;
-  Int32    opens;
-  Int64  open_time;
-} SQLPROC_CTRS_DEF;
-
-//#pragma section MEASCHECKITOUT
-//extern _tal _callable int_16 MEASCHECKITOUT();
-
-enum {MEASURE_NOTHING = 0};
-enum {MEASURE_STMT_ONLY = 1};
-enum {MEASURE_PROC_ONLY = 2};
-enum {MEASURE_PROC_AND_STMTS = 3};
-
-//#pragma section MEASSQLPROCBUMP
-//extern _tal _callable _resident int_16 MEASSQLPROCBUMP
-// (SQLPROC_CTRS_DEF  *sqlproc_ctrs);
-
-//#pragma section MEASSQLSTMTBUMP
-//extern _tal _callable _resident _extensible int_16 MEASQLSTMTBUMP
-//  (SQLSTMT_CTRS_DEF *sqlstmt_ctrs,
-//   int_16  num_stmts,
-//   int_16  total_proc,
-//   int_16  caller);
-
-enum {SQL_MP_CALLER = 1};   // parameters to be passed in MEASQLSTMTBUMP
-enum {SQL_ARK_CALLER = 2};
-
-#endif  /* _DMEASQL defined */


Mime
View raw message