| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| **************************************************************************** |
| * |
| * File: ComTdbSplitBottom.h |
| * Description: |
| * |
| * Created: 5/6/98 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| #ifndef COM_SPLIT_BOTTOM_H |
| #define COM_SPLIT_BOTTOM_H |
| |
| #include "ComTdb.h" |
| #include "FragDir.h" |
| #include "ComTdbSendBottom.h" |
| #include "ComExtractInfo.h" |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // contents of this file |
| //////////////////////////////////////////////////////////////////////////// |
| class ComTdbSplitBottom; |
| class SplitBottomPartInfo; |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // forward references |
| //////////////////////////////////////////////////////////////////////////// |
| class ComTdbSendBottom; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Class SplitBottomSkewInfo -- helps split bottom by encapsulating the |
| // skew buster information, including hash values |
| // of the partitioning keys containing values with very high occurence |
| // frequency, either in the data stream that this split bottom is |
| // producing, or in the relation to which this split bottom's data will be |
| // joined. |
| //////////////////////////////////////////////////////////////////////////// |
| |
| class SplitBottomSkewInfo : public NAVersionedObject |
| { |
| friend class ComTdbSplitBottom; |
| |
| public: |
| SplitBottomSkewInfo () : |
| NAVersionedObject(-1), |
| numSkewHashValues_(0), |
| skewHashValues_(NULL) {} |
| |
| SplitBottomSkewInfo ( Int32 numSkewHashValues, |
| Int64 * skewHashValues ) : |
| numSkewHashValues_(numSkewHashValues), |
| skewHashValues_(skewHashValues) {} |
| |
| const Int64 *getSkewHashValues(void) { return skewHashValues_; }; |
| |
| const Int32 getNumSkewHashValues(void) { return numSkewHashValues_; }; |
| |
| // --------------------------------------------------------------------- |
| // Redefine virtual functions required for Versioning. |
| //---------------------------------------------------------------------- |
| virtual unsigned char getClassVersionID() |
| { |
| return 1; |
| } |
| |
| virtual void populateImageVersionIDArray() |
| { |
| setImageVersionID(0,getClassVersionID()); |
| } |
| |
| virtual short getClassSize() { return (short)sizeof(SplitBottomSkewInfo); } |
| |
| |
| Long pack(void *); |
| Lng32 unpack(void * base, void * reallocator); |
| |
| private: |
| Int32 numSkewHashValues_; // 00-03 |
| char fillersSplitBottomSkewInfo_[4]; // 04-07 |
| Int64Ptr skewHashValues_; // 08-15 |
| char fillersSplitBottomSkewInfo2_[48]; // 16-63 |
| }; |
| |
| // --------------------------------------------------------------------- |
| // Template instantiation to produce a 64-bit pointer emulator class |
| // for SplitBottomSkewInfo |
| // --------------------------------------------------------------------- |
| typedef NAVersionedObjectPtrTempl<SplitBottomSkewInfo> SplitBottomSkewInfoPtr; |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Task Definition Block for split bottom node |
| //////////////////////////////////////////////////////////////////////////// |
| class ComTdbSplitBottom : public ComTdb |
| { |
| friend class ex_split_bottom_tcb; |
| |
| public: |
| // Constructors |
| ComTdbSplitBottom() : ComTdb(ex_SPLIT_BOTTOM,"FAKE") {} |
| |
| // real constructor, used by generator |
| ComTdbSplitBottom(ComTdb *child, |
| ComTdbSendBottom *sendTdb, |
| ex_expr *partFunction, |
| Lng32 partNoATPIndex, |
| Lng32 partFunctionUsesNarrow, |
| Lng32 conversionErrorFlagATPIndex, |
| Lng32 partInputATPIndex, |
| Lng32 partInputDataLen, |
| Cardinality estimatedRowCount, |
| ex_cri_desc *givenCriDesc, |
| ex_cri_desc *returnedCriDesc, |
| ex_cri_desc *workCriDesc, |
| NABoolean combineRequests, |
| Lng32 topNumESPs, |
| Lng32 topNumParts, |
| Lng32 bottomNumESPs, |
| Lng32 bottomNumParts, |
| SplitBottomSkewInfo *skewInfo |
| ); |
| |
| // --------------------------------------------------------------------- |
| // Redefine virtual functions required for Versioning. |
| //---------------------------------------------------------------------- |
| virtual unsigned char getClassVersionID() |
| { |
| return 1; |
| } |
| |
| virtual void populateImageVersionIDArray() |
| { |
| setImageVersionID(1,getClassVersionID()); |
| ComTdb::populateImageVersionIDArray(); |
| } |
| |
| virtual short getClassSize() { return (short)sizeof(ComTdbSplitBottom); } |
| |
| Int32 orderedQueueProtocol() const; |
| |
| inline Lng32 getPartInputDataLen() const { return partInputDataLen_; } |
| |
| Long pack(void *); |
| Lng32 unpack(void *, void * reallocator); |
| |
| void display() const; |
| |
| ComTdbSendBottom * getSendBottomTdb() const { return sendTdb_; } |
| |
| inline ULng32 getPlanVersion() const { return planVersion_; } |
| |
| virtual void setPlanVersion(UInt32 value) { planVersion_ = value; } |
| |
| NABoolean useSkewBuster() const |
| { return (splitBottomFlags_ & SKEWBUSTER) != 0; } |
| |
| void setUseSkewBuster(NABoolean v) |
| { (v ? splitBottomFlags_ |= SKEWBUSTER : splitBottomFlags_ &= ~SKEWBUSTER); } |
| |
| NABoolean doBroadcastSkew() const |
| { return (splitBottomFlags_ & SKEW_BROADCAST) != 0; } |
| |
| void setBroadcastSkew(NABoolean v) |
| { (v ? splitBottomFlags_ |= SKEW_BROADCAST : |
| splitBottomFlags_ &= ~SKEW_BROADCAST); } |
| |
| NABoolean getBroadcastOneRow() const |
| { return (splitBottomFlags_ & ONE_ROW_BROADCAST) != 0; } |
| |
| void setBroadcastOneRow(NABoolean v) |
| { (v ? splitBottomFlags_ |= ONE_ROW_BROADCAST : |
| splitBottomFlags_ &= ~ONE_ROW_BROADCAST); } |
| |
| NABoolean forceSkewRoundRobin() const |
| { return (splitBottomFlags_ & SKEW_FORCE_RR) != 0; } |
| |
| void setForceSkewRoundRobin(NABoolean v) |
| { (v ? splitBottomFlags_ |= SKEW_FORCE_RR: |
| splitBottomFlags_ &= ~SKEW_FORCE_RR); } |
| |
| // For SeaMonster |
| // * The "exchange uses SM" flag means this exchange uses SeaMonster |
| // * The "query uses SM" flag means SeaMonster is used somewhere in |
| // the query but not necessarily in this fragment |
| NABoolean getExchangeUsesSM() const |
| { return (splitBottomFlags_ & SPLB_EXCH_USES_SM) ? TRUE : FALSE; } |
| void setExchangeUsesSM() { splitBottomFlags_ |= SPLB_EXCH_USES_SM; } |
| |
| NABoolean getQueryUsesSM() const |
| { return (splitBottomFlags_ & SPLB_QUERY_USES_SM) ? TRUE : FALSE; } |
| void setQueryUsesSM() { splitBottomFlags_ |= SPLB_QUERY_USES_SM; } |
| |
| Int32 getInitialRoundRobin() const { return initialRoundRobin_; } |
| |
| void setInitialRoundRobin(Int32 ir) { initialRoundRobin_ = ir; } |
| |
| Int32 getFinalRoundRobin() const { return finalRoundRobin_; } |
| |
| void setFinalRoundRobin(Int32 fr) { finalRoundRobin_ = fr; } |
| |
| // These functions allow split bottom tcb initialization methods to read |
| // the hash values for the skewed partitioning key values. |
| SplitBottomSkewInfo *getSkewInfo() { return skewInfo_; } |
| const Int32 getNumSkewValues(void) |
| { return getSkewInfo()->numSkewHashValues_; } |
| // those 3 lines won't be covered, code nowhere used |
| Int64 const * hashValueArray(void) |
| { return getSkewInfo()->skewHashValues_; } |
| |
| // for GUI |
| virtual const ComTdb* getChild(Int32 pos) const; |
| virtual Int32 numChildren() const; |
| virtual const char *getNodeName() const { return "EX_SPLIT_BOTTOM"; }; |
| virtual Int32 numExpressions() const; |
| virtual ex_expr* getExpressionNode(Int32 pos); |
| virtual const char * getExpressionName(Int32 pos) const; |
| |
| // for showplan |
| virtual void displayContents(Space *space,ULng32 flag); |
| |
| // For parallel extract |
| NABoolean getExtractProducerFlag() const |
| { return (splitBottomFlags_ & EXTRACT_PRODUCER) ? TRUE : FALSE; } |
| void setExtractProducerFlag() { splitBottomFlags_ |= EXTRACT_PRODUCER; } |
| |
| const char *getExtractSecurityKey() const |
| { return (extractProducerInfo_ ? |
| extractProducerInfo_->getSecurityKey() : NULL); } |
| |
| void setExtractProducerInfo(ComExtractProducerInfo *e) |
| { extractProducerInfo_ = e; } |
| |
| NABoolean isMWayRepartition() const |
| { return (splitBottomFlags_ & MWAY_REPARTITION) ? TRUE : FALSE; } |
| void setMWayRepartitionFlag() {splitBottomFlags_ |= MWAY_REPARTITION; } |
| |
| NABoolean isAnESPAccess() const |
| { return (splitBottomFlags_ & ESP_ACCESS) ? TRUE : FALSE; } |
| void setIsAnESPAccess() {splitBottomFlags_ |= ESP_ACCESS; } |
| |
| NABoolean getQueryLimitDebug() const |
| { return (splitBottomFlags_ & QUERY_LIMIT_DEBUG) ? TRUE: FALSE; } |
| void setQueryLimitDebug() {splitBottomFlags_ |= QUERY_LIMIT_DEBUG; } |
| |
| enum { |
| NO_ABEND = 0, |
| SIGNED_OVERFLOW, |
| ASSERT, |
| INVALID_MEMORY, |
| SLEEP180, |
| INTERNAL_ERROR, |
| TEST_LOG4CXX |
| }; |
| |
| Int32 getAbendType(void) const { return abendType_; } |
| |
| void setAbendType(Int32 a) { abendType_ = a; } |
| |
| void setCpuLimit(Int64 cpuLimit) { cpuLimit_ = cpuLimit; } |
| |
| void setCpuLimitCheckFreq(Int32 f) { cpuLimitCheckFreq_ = f; } |
| |
| protected: |
| |
| enum split_bottom_flags { SKEWBUSTER = 0x0001 |
| , SKEW_BROADCAST = 0x0002 |
| , SKEW_FORCE_RR = 0x0004 |
| , EXTRACT_PRODUCER = 0x0008 |
| , MWAY_REPARTITION = 0x0010 |
| , ESP_ACCESS = 0x0020 |
| , QUERY_LIMIT_DEBUG = 0x0040 |
| , ONE_ROW_BROADCAST = 0x0080 |
| , SPLB_QUERY_USES_SM = 0x0100 |
| , SPLB_EXCH_USES_SM = 0x0200 |
| }; |
| |
| // the combination of a split top / split bottom node maps bottomNumParts_ |
| // partitions from bottomNumESPs_ processes into topNumParts_ partitions |
| // in topNumESPs_ processes. |
| Int32 topNumESPs_; // 00-03 |
| Int32 topNumParts_; // 04-07 |
| Int32 bottomNumESPs_; // 08-11 |
| Int32 bottomNumParts_; // 12-15 |
| |
| // an expression used to determine to which output partition to send |
| // a value that came from our child's up queue (if partFunction_ is not |
| // existent then the value is sent to all output partitions that generated |
| // the corresponding input queue entry) |
| ExExprPtr partFunction_; // 16-23 |
| Int32 partNoATPIndex_; // 24-27 |
| |
| // does the partitioning function possibly fail with a data conversion |
| // error? |
| Int32 partFuncUsesNarrow_; // boolean value; 28-31 |
| Int32 convErrorATPIndex_; // 32-35 |
| |
| // info on where the partition input tupp is stored in the work atp |
| Int32 partInputATPIndex_; // 36-39 |
| |
| // record descriptions of local ATPs |
| ExCriDescPtr workCriDesc_; // 40-47 |
| |
| // the partition input values are values sent by some process, identifying |
| // the partition that this ESP is working on (this may be a partition number |
| // or a begin/end key pair); the partition input values are passed on |
| // to our child as an input value |
| Int32 partInputDataLen_; // 48-51 |
| |
| // The split bottom node can treat each request coming in as a separate |
| // job and execute it. Most of the time, however, all requesters send a |
| // request synchronously and the split bottom node is supposed to process |
| // all those (identical) requests as a single unit. |
| Int32 combineRequests_; // 52-55 |
| |
| ComTdbPtr child_; // 56-63 |
| |
| // node to communicate with requester |
| ComTdbSendBottomPtr sendTdb_; // 64-71 |
| |
| UInt16 splitBottomFlags_; // 72-73 |
| |
| Int16 initialRoundRobin_; // 74-75 |
| |
| UInt32 planVersion_; // 76-79 |
| |
| |
| |
| SplitBottomSkewInfoPtr skewInfo_; // 80-87 |
| |
| ComExtractProducerInfoPtr extractProducerInfo_; // 88-95 |
| |
| Int32 abendType_; // 96-99 |
| |
| UInt16 finalRoundRobin_ ; // 100-101 |
| Int16 cpuLimitCheckFreq_; // 102-103 |
| Int64 cpuLimit_; // 104-111 |
| char fillersComTdbSplitBottom_[8]; // 112-119 |
| |
| }; |
| |
| #endif /* EX_SPLIT_BOTTOM_H */ |
