Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 76032200D08 for ; Thu, 7 Sep 2017 03:55:16 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 745251609C5; Thu, 7 Sep 2017 01:55:16 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 21529161A20 for ; Thu, 7 Sep 2017 03:55:13 +0200 (CEST) Received: (qmail 83178 invoked by uid 500); 7 Sep 2017 01:55:13 -0000 Mailing-List: contact commits-help@trafodion.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: commits@trafodion.apache.org Delivered-To: mailing list commits@trafodion.apache.org Received: (qmail 83169 invoked by uid 99); 7 Sep 2017 01:55:13 -0000 Received: from pnap-us-west-generic-nat.apache.org (HELO spamd1-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 07 Sep 2017 01:55:13 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd1-us-west.apache.org (ASF Mail Server at spamd1-us-west.apache.org) with ESMTP id C7351CD8A4 for ; Thu, 7 Sep 2017 01:55:12 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd1-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: -4.212 X-Spam-Level: X-Spam-Status: No, score=-4.212 tagged_above=-999 required=6.31 tests=[KAM_ASCII_DIVIDERS=0.8, RCVD_IN_DNSWL_HI=-5, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, RP_MATCHES_RCVD=-0.001, SPF_PASS=-0.001, T_FILL_THIS_FORM_LOAN=0.01] autolearn=disabled Received: from mx1-lw-eu.apache.org ([10.40.0.8]) by localhost (spamd1-us-west.apache.org [10.40.0.7]) (amavisd-new, port 10024) with ESMTP id Uu5M9tnWBHjc for ; Thu, 7 Sep 2017 01:54:59 +0000 (UTC) Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-lw-eu.apache.org (ASF Mail Server at mx1-lw-eu.apache.org) with SMTP id D1CBA5FCCB for ; Thu, 7 Sep 2017 01:54:57 +0000 (UTC) Received: (qmail 82127 invoked by uid 99); 7 Sep 2017 01:54:57 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 07 Sep 2017 01:54:57 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 40C1AF5533; Thu, 7 Sep 2017 01:54:55 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: ansharma@apache.org To: commits@trafodion.incubator.apache.org Date: Thu, 07 Sep 2017 01:55:09 -0000 Message-Id: <9cc03c1d2f4c4b70844326d15d158c06@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [15/30] incubator-trafodion git commit: TRAFODION-2731 CodeCleanup: Remove obsolete, legacy and unused code archived-at: Thu, 07 Sep 2017 01:55:16 -0000 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 */