| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| #ifndef RELSCAN_H |
| #define RELSCAN_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: RelScan.h |
| * Description: Relational scan (both physical and logical operators) |
| * Created: 4/28/94 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| // ----------------------------------------------------------------------- |
| |
| #include "ComSmallDefs.h" |
| #include "ObjectNames.h" |
| #include "RelExpr.h" |
| #include "SearchKey.h" |
| #include "mdam.h" |
| #include "mdamkey.h" |
| #include "disjuncts.h" |
| #include "OptUtilIncludes.h" |
| #include "CmpContext.h" |
| #include "SchemaDB.h" |
| #include "HbaseSearchSpec.h" |
| #include "OptHints.h" |
| #include "ExpHbaseDefs.h" |
| #include <vector> |
| |
| // ----------------------------------------------------------------------- |
| // contents of this file |
| // ----------------------------------------------------------------------- |
| class Scan; |
| class FileScan; |
| |
| // a helper class used by class Scan |
| class ScanIndexInfo; |
| class IndexProperty; |
| |
| // ----------------------------------------------------------------------- |
| // forward references |
| // ----------------------------------------------------------------------- |
| class BindWA; |
| class CostScalar; |
| class Generator; |
| class GenericUpdate; |
| class LogicalProperty; |
| class NormWA; |
| class SimpleCostVector; |
| class TableDesc; |
| class MVInfoForDML; |
| class DeltaDefinition; |
| class MvRefreshBuilder; |
| //////////////////// |
| class QueryAnalysis; |
| class CANodeId; |
| class JBBSubsetAnalysis; |
| //////////////////// |
| |
| class QRDescGenerator; |
| class RangeSpecRef; |
| |
| class MVMatch; |
| class CommonSubExprRef; |
| |
| |
| /************************* |
| MdamFlags used to indicate promise of key access of an index |
| *************************/ |
| #ifndef MDAM_FLAGS |
| #define MDAM_FLAGS |
| enum MdamFlags { UNDECIDED, |
| MDAM_ON, |
| MDAM_OFF |
| }; |
| #endif |
| |
| /****************************** |
| IndexJoinSelectivityEnum indicates if the cost of index join would |
| exceed the cost of scanning the base table or not. |
| *******************************/ |
| #ifndef INDEX_JOIN_SLECTIVITY |
| #define INDEX_JOIN_SLECTIVITY |
| enum IndexJoinSelectivityEnum { |
| INDEX_ONLY_INDEX, |
| INDEX_JOIN_VIABLE, |
| EXCEEDS_BT_SCAN |
| }; |
| #endif |
| |
| |
| |
| |
| // ----------------------------------------------------------------------- |
| // A helper class for class Scan that identifies sets of indexes to be |
| // used in transformations of this scan to an index join (a join between |
| // an index and another scan node). Only the friends should use this |
| // class. |
| // ----------------------------------------------------------------------- |
| class ScanIndexInfo : public NABasicObject |
| { |
| friend class Scan; |
| friend class IndexJoinRule1; |
| friend class IndexJoinRule2; |
| friend class OrOptimizationRule; |
| public: |
| ScanIndexInfo( |
| const ValueIdSet& inputsToIndex, |
| const ValueIdSet& outputsFromIndex, |
| const ValueIdSet& indexPredicates, |
| const ValueIdSet& joinPredicates, |
| const ValueIdSet& outputsFromRightScan, |
| const ValueIdSet& indexColumns, |
| IndexProperty* ixProp |
| ); |
| |
| ScanIndexInfo(const ScanIndexInfo & other); |
| |
| private: |
| |
| ValueIdSet inputsToIndex_; |
| ValueIdSet outputsFromIndex_; |
| ValueIdSet indexPredicates_; |
| ValueIdSet joinPredicates_; |
| ValueIdSet outputsFromRightScan_; |
| ValueIdSet indexColumns_; |
| SET(IndexProperty *) usableIndexes_; |
| NABoolean transformationDone_; |
| }; |
| |
| |
| /**************************************************************** |
| Helper class used to encapsulate properties of an index like promise |
| of key access, viability of index join. Default inputLogProp used to |
| calculate cost of index join. |
| ****************************************************************/ |
| class IndexProperty : public NABasicObject |
| { |
| |
| public: |
| |
| IndexProperty(IndexDesc * index, |
| MdamFlags mdamFlag = MDAM_ON, |
| IndexJoinSelectivityEnum selectivity = INDEX_ONLY_INDEX, |
| const EstLogPropSharedPtr& inELP = NULL): |
| index_(index),mdamFlag_(mdamFlag), |
| selectivityEnum_(selectivity), |
| inputEstLogProp_(inELP) |
| {} |
| |
| //mutator functions |
| void setSelectivity(IndexJoinSelectivityEnum selectivity) |
| { selectivityEnum_ = selectivity; } |
| void setMdamFlag(MdamFlags mdamFlag) |
| { mdamFlag_ = mdamFlag ; } |
| void setInputEstLogProp(const EstLogPropSharedPtr& inELP) |
| { inputEstLogProp_ = inELP; } |
| //Accessor functions |
| IndexDesc * getIndexDesc() const |
| { return index_; } |
| MdamFlags getMdamFlag() const |
| { return mdamFlag_; } |
| IndexJoinSelectivityEnum getSelectivity() const |
| { return selectivityEnum_; } |
| EstLogPropSharedPtr getInputEstLogProp() const |
| { return inputEstLogProp_; } |
| void updatePossibleIndexes(SET(IndexProperty *) & ixOnlyIndexes, Scan * ); |
| COMPARE_RESULT compareIndexPromise(const IndexProperty *) const; |
| |
| private: |
| IndexDesc * index_; |
| MdamFlags mdamFlag_; |
| IndexJoinSelectivityEnum selectivityEnum_; |
| EstLogPropSharedPtr inputEstLogProp_; |
| }; |
| // ----------------------------------------------------------------------- |
| // The Scan operator forms the leaf nodes of a tree of relational |
| // expressions. |
| // ----------------------------------------------------------------------- |
| |
| class Scan : public RelExpr |
| { |
| public: |
| |
| // constructor |
| Scan(OperatorTypeEnum otype = REL_SCAN, |
| CollHeap *oHeap = CmpCommon::statementHeap(), |
| NABoolean stream = FALSE ) : |
| RelExpr(otype, NULL, NULL, oHeap), |
| userTableName_("", oHeap), |
| tabId_(NULL), |
| numIndexJoins_(0), |
| indexOnlyIndexes_(oHeap), |
| indexOnlyScans_(oHeap), |
| indexJoinScans_(oHeap), |
| possibleIndexJoins_(oHeap), |
| isSingleVPScan_(FALSE), |
| stoi_(NULL), |
| samplePercent_(-1.0), |
| clusterSize_(0), |
| scanFlags_(0), |
| // QSTUFF |
| stream_ (stream), |
| embeddedUpdateOrDelete_ (FALSE), |
| forcedIndexInfo_(FALSE), |
| suppressHints_(FALSE), |
| baseCardinality_(0), |
| // QSTUFF |
| isRewrittenMV_(FALSE), |
| matchingMVs_(oHeap), |
| hbaseAccessOptions_(NULL), |
| commonSubExpr_(NULL) |
| {} |
| |
| Scan(const CorrName& name, |
| NABoolean stream = FALSE) : |
| RelExpr(REL_SCAN, NULL, NULL, CmpCommon::statementHeap()), |
| userTableName_(name, CmpCommon::statementHeap()), |
| tabId_(NULL), |
| numIndexJoins_(0), |
| indexOnlyIndexes_(CmpCommon::statementHeap()), |
| indexOnlyScans_(CmpCommon::statementHeap()), |
| indexJoinScans_(CmpCommon::statementHeap()), |
| possibleIndexJoins_(CmpCommon::statementHeap()), |
| isSingleVPScan_(FALSE), |
| stoi_(NULL), |
| samplePercent_(-1.0), |
| clusterSize_(0), |
| scanFlags_(0), |
| // QSTUFF |
| stream_ (stream), |
| embeddedUpdateOrDelete_ (FALSE), |
| forcedIndexInfo_(FALSE), |
| suppressHints_(FALSE), |
| baseCardinality_(0), |
| // QSTUFF |
| isRewrittenMV_(FALSE), |
| matchingMVs_(CmpCommon::statementHeap()), |
| hbaseAccessOptions_(NULL), |
| commonSubExpr_(NULL) |
| {} |
| |
| Scan(const CorrName& name, |
| TableDesc * tabId, |
| OperatorTypeEnum otype = REL_SCAN, |
| CollHeap *oHeap = CmpCommon::statementHeap(), |
| NABoolean stream = FALSE) : |
| RelExpr(otype, NULL, NULL, oHeap), |
| userTableName_(name, oHeap), |
| tabId_(tabId), |
| numIndexJoins_(0), |
| indexOnlyIndexes_(oHeap), |
| indexOnlyScans_(oHeap), |
| indexJoinScans_(oHeap), |
| possibleIndexJoins_(oHeap), |
| isSingleVPScan_(FALSE), |
| stoi_(NULL), |
| samplePercent_(-1.0), |
| clusterSize_(0), |
| scanFlags_(0), |
| // QSTUFF |
| stream_ (stream), |
| embeddedUpdateOrDelete_ (FALSE), |
| forcedIndexInfo_(FALSE), |
| suppressHints_(FALSE), |
| baseCardinality_(0), |
| // QSTUFF |
| isRewrittenMV_(FALSE), |
| matchingMVs_(oHeap), |
| hbaseAccessOptions_(NULL), |
| commonSubExpr_(NULL) |
| {} |
| |
| Scan(OperatorTypeEnum otype, |
| const CorrName& name, |
| CollHeap *oHeap = CmpCommon::statementHeap()) : |
| RelExpr(otype, NULL, NULL, oHeap), |
| userTableName_(name, CmpCommon::statementHeap()), |
| tabId_(NULL), |
| numIndexJoins_(0), |
| indexOnlyIndexes_(CmpCommon::statementHeap()), |
| indexOnlyScans_(CmpCommon::statementHeap()), |
| indexJoinScans_(CmpCommon::statementHeap()), |
| possibleIndexJoins_(CmpCommon::statementHeap()), |
| isSingleVPScan_(FALSE), |
| stoi_(NULL), |
| samplePercent_(-1.0), |
| clusterSize_(0), |
| scanFlags_(0), |
| // QSTUFF |
| stream_ (FALSE), |
| embeddedUpdateOrDelete_ (FALSE), |
| forcedIndexInfo_(FALSE), |
| suppressHints_(FALSE), |
| baseCardinality_(0), |
| // QSTUFF |
| isRewrittenMV_(FALSE), |
| hbaseAccessOptions_(NULL), |
| matchingMVs_(CmpCommon::statementHeap()), |
| commonSubExpr_(NULL) |
| {} |
| |
| // virtual destructor |
| virtual ~Scan() {} |
| |
| // append an ascii-version of RelExpr into cachewa.qryText_ |
| virtual void generateCacheKey(CacheWA& cwa) const; |
| |
| // is this entire expression cacheable after this phase? |
| virtual NABoolean isCacheableExpr(CacheWA& cwa); |
| |
| // change literals of a cacheable query into ConstantParameters |
| virtual RelExpr* normalizeForCache(CacheWA& cwa, BindWA& bindWA); |
| |
| // get the degree of this node (it is a leaf). |
| virtual Int32 getArity() const; |
| |
| virtual NABoolean isHbaseScan() { return FALSE; } |
| |
| // get and set the table name |
| virtual const CorrName & getTableName() const { return userTableName_; } |
| virtual CorrName & getTableName() { return userTableName_; } |
| virtual const CorrName * getPtrToTableName() const { return &userTableName_; } |
| |
| virtual void setTableName(CorrName &userTableName) |
| { |
| userTableName_ = userTableName; |
| } |
| |
| // Methods for accessing and updating the TableDesc |
| TableDesc * getTableDesc() const { return tabId_; } |
| void setTableDesc(TableDesc * tdesc) { tabId_ = tdesc; } |
| |
| TableDesc * getTableDescForBaseSelectivity() { return tabId_; } |
| |
| // This method computes the base selectivity for this table. It is defined |
| // cardinality after applying all local predicates with empty input logical |
| // properties over the base cardinality without hints |
| CostScalar computeBaseSelectivity() const; |
| |
| const SET(IndexProperty *) & getIndexOnlyIndexes() { return indexOnlyIndexes_; } |
| const LIST(ScanIndexInfo *) & getPossibleIndexJoins() |
| { return possibleIndexJoins_; } |
| Lng32 getNumIndexJoins() { return numIndexJoins_; } |
| void setNumIndexJoins(Lng32 n) { numIndexJoins_ = n; } |
| |
| void setHbaseAccessOptions(HbaseAccessOptions *v) { hbaseAccessOptions_ = v; } |
| HbaseAccessOptions *getHbaseAccessOptions() const { return hbaseAccessOptions_; } |
| |
| // the maximal number of index joins that a scan node will be |
| // transformed into |
| static const Lng32 MAX_NUM_INDEX_JOINS; |
| |
| NABoolean isHiveTable() const; |
| NABoolean isHbaseTable() const; |
| NABoolean isSeabaseTable() const; |
| |
| // a virtual function for performing name binding within the query tree |
| virtual RelExpr * bindNode(BindWA *bindWAPtr); |
| |
| // MV -- |
| NABoolean virtual isIncrementalMV() { return TRUE; } |
| void virtual collectMVInformation(MVInfoForDDL *mvInfo, |
| NABoolean isNormalized); |
| RelExpr *bindExpandedMaterializedView(BindWA *bindWA, NATable *naTable); |
| void projectCurrentEpoch(BindWA *bindWA); |
| |
| // Each operator supports a (virtual) method for transforming its |
| // scalar expressions to a canonical form |
| virtual void transformNode(NormWA & normWARef, |
| ExprGroupId & locationOfPointerToMe); |
| |
| // Each operator supports a (virtual) method for rewriting its |
| // value expressions. |
| virtual void rewriteNode(NormWA & normWARef); |
| |
| // The set of values that I can potentially produce as output. |
| virtual void getPotentialOutputValues(ValueIdSet & vs) const; |
| |
| virtual void getPotentialOutputValuesAsVEGs(ValueIdSet & outputs) const ; |
| |
| // synthesize logical properties |
| virtual void synthLogProp(NormWA * normWAPtr = NULL); |
| |
| // synthesize complementary Referential opt constraints |
| // used to eliminate redundant joins and match extra-hub tables. |
| void synthCompRefOptConstraints(NormWA * normWAPtr) ; |
| |
| // finish synthesis of logical properties by setting the cardinality |
| // attributes |
| virtual void finishSynthEstLogProp(); |
| |
| virtual void synthEstLogProp(const EstLogPropSharedPtr& inputEstLogProp); |
| |
| |
| // Generate the read access set. |
| virtual SubTreeAccessSet * calcAccessSets(CollHeap *heap); |
| |
| // reconcile GroupAttribute |
| virtual NABoolean reconcileGroupAttr(GroupAttributes *newGroupAttr); |
| |
| // find out which indexes on the base table are usable for this scan |
| void addIndexInfo(); |
| NABoolean updateableIndex(IndexDesc*, ValueIdSet& preds, |
| NABoolean & needsHalloweenProtection); |
| NABoolean requiresHalloweenForUpdateUsingIndexScan(); |
| |
| // iterate over the usable indexes (index-only and index joins) |
| CollIndex numUsableIndexes(); |
| |
| IndexDesc *getUsableIndex(CollIndex indexNum, |
| IndexProperty **indexOnlyInfo = NULL, |
| ScanIndexInfo **indexJoinInfo = NULL); |
| |
| // add all base cols that contribute to local VEGPredicates to vs |
| void addBaseColsFromVEGPreds(ValueIdSet &vs) const; |
| |
| // set the list of indexonly indexes externally |
| |
| void setIndexOnlyScans(const SET(IndexProperty *) &ixonly) |
| { indexOnlyIndexes_ = ixonly; } |
| const SET(IndexDesc *)& deriveIndexOnlyIndexDesc(); |
| const SET(IndexDesc *)& deriveIndexJoinIndexDesc(); |
| const SET(IndexDesc *)& getIndexJoinIndexDesc(){ return indexJoinScans_; } |
| inline void setComputedPredicates(const ValueIdSet &ccPreds) |
| { generatedCCPreds_ = ccPreds; } |
| |
| const LIST(ScanIndexInfo *) &getIndexInfo() |
| { return possibleIndexJoins_; } |
| const ValueIdSet &getComputedPredicates() const { return generatedCCPreds_; } |
| |
| // set (restrict) the potential output values that this node can produce |
| void setPotentialOutputValues(const ValueIdSet &po) |
| { potentialOutputs_ = po; } |
| |
| Cardinality getBaseCardinality() const |
| { return baseCardinality_; } |
| |
| void setBaseCardinality(Cardinality newCard) |
| { baseCardinality_ = newCard; } |
| |
| void setTableAttributes(CANodeId nodeId); |
| |
| virtual HashValue topHash(); |
| virtual NABoolean duplicateMatch(const RelExpr & other) const; |
| virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL, |
| CollHeap* outHeap = 0); |
| void copyIndexInfo(RelExpr *derivedNode); |
| void removeIndexInfo(); |
| // add all the expressions that are local to this |
| // node to an existing list of expressions (used by GUI tool) |
| virtual void addLocalExpr(LIST(ExprNode *) &xlist, |
| LIST(NAString) &llist) const; |
| |
| virtual void computeMyRequiredResources(RequiredResources & reqResources, |
| EstLogPropSharedPtr & inLP); |
| |
| // get a printable string that identifies the operator |
| virtual const NAString getText() const; |
| |
| const StmtLevelAccessOptions accessOptions() const { return accessOptions_; } |
| StmtLevelAccessOptions &accessOptions() { return accessOptions_; } |
| |
| const SelectivityHint * getSelectivityHint() const |
| { return (suppressHints_ ? NULL : tabId_->getSelectivityHint()); } |
| const CardinalityHint * getCardinalityHint() const |
| { return (suppressHints_ ? NULL : tabId_->getCardinalityHint()); } |
| |
| // --------------------------------------------------------------------- |
| // Scan::normalizeNode() |
| // Invokes ItemExpr::normalizeNode() & then performs mdamBuildDisjuncts |
| // --------------------------------------------------------------------- |
| RelExpr * normalizeNode ( NormWA & normWARef ); |
| |
| virtual NABoolean prepareMeForCSESharing( |
| const ValueIdSet &outputsToAdd, |
| const ValueIdSet &predicatesToRemove, |
| const ValueIdSet &commonPredicatesToAdd, |
| const ValueIdSet &inputsToRemove, |
| ValueIdSet &valuesForVEGRewrite, |
| ValueIdSet &keyColumns, |
| CSEInfo *info); |
| |
| // synthesizes compRefOpt constraints. |
| virtual void processCompRefOptConstraints(NormWA * normWAPtr) ; |
| |
| // checks if the scan on the referenced table contains predicates of the form |
| //table.col = 1, or table.col > 1, or (fktable.col = 1 and fktable.col = table.col) |
| // in these examples the col in table.col has to be a non key column. If its a key |
| //column then the predicate is not reducing in the foreignkey-uniquekey sense because |
| // if there table.uniquekey = fktable.foriegnkey type predicate then that predicate |
| // will ensure that table.uniquekey = 1 type predicate is also applied to the |
| // foreign key side and therefore it does not destroy the FK-UK relation. |
| NABoolean containsReducingPredicates(const ValueIdSet& keyCols) const; |
| |
| void setForceIndexInfo() { forcedIndexInfo_ = TRUE; } |
| void resetForceIndexInfo() { forcedIndexInfo_ = FALSE; } |
| NABoolean isIndexInfoForced() const { return forcedIndexInfo_; } |
| |
| void setSuppressHints(NABoolean x = TRUE) { suppressHints_ = x; } |
| NABoolean areHintsSuppressed() const { return suppressHints_; } |
| |
| // --------------------------------------------------------------------- |
| // Vertical Partitioning related methods |
| // --------------------------------------------------------------------- |
| // checks if TableDesc has vertical partitions |
| NABoolean isVerticalPartitionTableScan() const |
| { return (!tabId_->getVerticalPartitions().isEmpty()); } |
| |
| // Returns isSingleVPScan |
| NABoolean isSingleVerticalPartitionScan() const { return isSingleVPScan_; } |
| |
| // Sets isSingleVPScan |
| void setSingleVerticalPartitionScan(NABoolean isSingleVPScan) |
| { isSingleVPScan_ = isSingleVPScan; } |
| |
| // find out which vertical partitions are needed for this scan |
| // and what columns does each of them provide |
| void getRequiredVerticalPartitions |
| (SET(IndexDesc *) & requiredVPs, |
| SET(ValueIdSet *) & columnsProvidedByVP) const; |
| |
| |
| // if update where current of, updateQry is set to TRUE. |
| // if del where cur of, set to FALSE. |
| void bindUpdateCurrentOf(BindWA *bindWA, NABoolean updateQry); |
| |
| ValueIdList & pkeyHvarList() { return pkeyHvarList_; } |
| |
| OptSqlTableOpenInfo *getOptStoi() const { return stoi_; }; |
| void setOptStoi(OptSqlTableOpenInfo *stoi) { stoi_ = stoi; }; |
| |
| Float32 samplePercent() const { return samplePercent_; }; |
| void samplePercent(Float32 sp) { samplePercent_ = sp; }; |
| |
| NABoolean checkForCardRange(const ValueIdSet & setOfPredicates, |
| CostScalar & newRowCount /* in and out */); |
| |
| NABoolean isSampleScan() const { return samplePercent_ >= 0; }; |
| inline ValueIdSet & sampledColumns() { return sampledColumns_; }; |
| inline const ValueIdSet & sampledColumns() const { return sampledColumns_; }; |
| |
| Lng32 clusterSize() const { return clusterSize_; }; |
| void clusterSize(Lng32 cs) { clusterSize_ = cs; }; |
| NABoolean isClusterSampling() const { return clusterSize_ > 0; }; |
| |
| NABoolean noSecurityCheck() { return (scanFlags_ & NO_SECURITY_CHECK) != 0; } |
| void setNoSecurityCheck(NABoolean v) |
| { (v ? scanFlags_ |= NO_SECURITY_CHECK : scanFlags_ &= ~NO_SECURITY_CHECK); } |
| |
| // QSTUFF VV |
| |
| // -------------------------------------------------------------------- |
| // This routine checks whether a table is both read and updated |
| // -------------------------------------------------------------------- |
| virtual rwErrorStatus checkReadWriteConflicts(NormWA & normWARef); |
| |
| // QSTUFF ^^ |
| |
| // 10-040128-2749 -begin |
| // check if Mdam is enabled based on the context,Current Controltable |
| // setting and defaults. |
| NABoolean isMdamEnabled(const Context *context); |
| // 10-040128-2749 -end |
| |
| // MV -- |
| // Force the Scan to be in the reverse order of the clustering index. |
| NABoolean forceInverseOrder() const { return (scanFlags_ & FORCE_INVERSE_ORDER) != 0; } |
| void setForceInverseOrder(NABoolean v=TRUE) |
| { (v ? scanFlags_ |= FORCE_INVERSE_ORDER : scanFlags_ &= ~FORCE_INVERSE_ORDER); } |
| |
| void setExtraOutputColumns(ValueIdSet outputCols) |
| { extraOutputColumns_ = outputCols; } |
| const ValueIdSet& getExtraOutputColumns() const |
| { return extraOutputColumns_;} |
| |
| void setRewrittenMV() { isRewrittenMV_ = TRUE; } |
| NABoolean isRewrittenMV() const { return isRewrittenMV_;} |
| |
| ////////////////////////////////////////////////////// |
| virtual NABoolean pilotAnalysis(QueryAnalysis* qa); |
| JBBSubsetAnalysis* getJBBSubsetAnalysis(); |
| ////////////////////////////////////////////////////// |
| |
| ItemExpr * applyAssociativityAndCommutativity(QRDescGenerator *descGenerator, |
| CollHeap *heap, ItemExpr *ptrToOldTree, NormWA& normWARef, |
| NABoolean& transformationStatus); |
| |
| NABoolean shrinkNewTree(OperatorTypeEnum op, ItemExpr *ptrToNewTree, |
| RangeSpecRef* xref, NormWA& normWARef); |
| |
| // for MVQR: return the list of matching MVs |
| NAList<MVMatch*> getMatchingMVs() |
| { return matchingMVs_; }; |
| |
| // Insert an MV match (for query rewrite purposes) into the list of potential |
| // replacements for the Scan. Preferred matches are inserted at the |
| // front of the list, non-preferred matches go at the end. |
| void addMVMatch(MVMatch* match, NABoolean isPreferred) |
| { |
| if (isPreferred) |
| matchingMVs_.insertAt(0, match); |
| else |
| matchingMVs_.insert(match); |
| } |
| |
| CommonSubExprRef *getCommonSubExpr() const { return commonSubExpr_; } |
| void setCommonSubExpr(CommonSubExprRef *cse) { commonSubExpr_ = cse; } |
| |
| protected: |
| |
| // Find the most promising index from the LIST, for index joins |
| IndexProperty* findSmallestIndex(const LIST(ScanIndexInfo *)&) const; |
| |
| // Find the most promising index from the set, for index only scans |
| IndexProperty* findSmallestIndex(const SET(IndexProperty *)& indexes) const; |
| |
| |
| // A help method to compute the cpu resource |
| CostScalar |
| computeCpuResourceRequired(const CostScalar& rowsToScan, const CostScalar& rowSize); |
| |
| // Compute the cpu resource for index join scan and index only scan. |
| CostScalar computeCpuResourceForIndexJoinScans(CANodeId tableId); |
| CostScalar computeCpuResourceForIndexOnlyScans(CANodeId tableId); |
| |
| // Compute the amount of work for one index join scan. |
| |
| // indexPredicates specifies the predicates on the index. The amout of the |
| // work is only computed for the key columns contained in the predicates. |
| CostScalar computeCpuResourceForIndexJoin(CANodeId tableId, IndexDesc* iDesc, |
| ValueIdSet& indexPredicates, |
| CostScalar& rowsToScan); |
| |
| // The work is only computed for the key columns contained in ikeys. |
| CostScalar computeCpuResourceForIndexJoin(CANodeId tableId, IndexDesc* iDesc, |
| const ValueIdList& ikeys, |
| CostScalar& rowsToScan); |
| |
| private: |
| |
| // the first param to this method, vid, is assumed to a OR predicate |
| // that meets all logical conditions such that it can be transformed |
| // to a IN subquery to be implemeneted using a semijoin |
| // this method applies various heuristics and returns a TRUE/FALSE |
| // answer as to whether applying the transformation will yield |
| // better plans. Method is called in Normalizer so we use |
| // heuristics rather than computed cost. |
| NABoolean passSemiJoinHeuristicCheck(ValueId vid, Lng32 numValues, |
| Lng32 numParams, ValueId colVid) const ; |
| |
| // NO_SECURITY_CHECK: if this Scan node was created as part of another |
| // operation (ex., UPDATE becomes UPDATE(SCAN) in parser), |
| // then no security check is needed. |
| enum ScanFlags { NO_SECURITY_CHECK = 0x0001, |
| FORCE_INVERSE_ORDER = 0x0002}; |
| |
| Cardinality baseCardinality_; // from table statistics |
| |
| // the user-specified name of the table |
| CorrName userTableName_; |
| |
| // a unique identifier for the table |
| TableDesc * tabId_; |
| |
| // The following two fields are set once by calling addIndexInfo(). |
| // all indexes that can deliver all the required values |
| SET(IndexProperty *) indexOnlyIndexes_; |
| SET(IndexDesc *) indexOnlyScans_; |
| SET(IndexDesc *) indexJoinScans_; |
| // all indexes that can't deliver all the required values plus |
| // some info about each of those indexes, calculated by addIndexInfo |
| LIST(ScanIndexInfo *) possibleIndexJoins_; |
| ValueIdSet generatedCCPreds_; |
| |
| // the values that this logical scan node can deliver after this |
| // set has been initialized to something other than an empty set |
| ValueIdSet potentialOutputs_; |
| |
| // indicate how many index joins on this table we've already done before |
| // creating this node |
| Lng32 numIndexJoins_; |
| |
| // Contains user specified BROWSE, STABLE or REPEATABLE access type and |
| // user specified SHARE or EXCLUSIVE lock mode. |
| StmtLevelAccessOptions accessOptions_; |
| |
| // See bindUpdateCurrentOf() for details on how this list is created. |
| ValueIdList pkeyHvarList_; |
| |
| // Indicates whether this Scan node is a Scan of a single vertical |
| // partition. It applies to only Scan nodes that have been generated by |
| // the VPJoinRule from a Scan of a vertically partitioned table. It is |
| // set to TRUE in VPJoinRule::nextSubstitute. |
| NABoolean isSingleVPScan_; |
| |
| // tables open information which is necessary during the open of a sql table. |
| OptSqlTableOpenInfo *stoi_; |
| |
| // -- Triggers |
| RelExpr *buildTriggerTransitionTableView(BindWA *bindWA); |
| |
| // The following data members are added to enable sampling in the |
| // scan operator. Currently Scan performs sampling also only if: |
| // 1. There are no selection predicates |
| // 2. The scan is not on multiple VP tables |
| // 3. Reverse ordering is not specified |
| // The Sample enabled scan performs only random sampling with relative |
| // size specification (as a percentage of the table size). |
| |
| // The sampled columns - for mapping the value ids between RelSample and |
| // Scan |
| // |
| ValueIdSet sampledColumns_; |
| |
| // Sample size in percentage (of the table size). Set to > 0.0 if sampling |
| // and -1.0 otherwise. |
| // |
| Float32 samplePercent_; |
| |
| // Cluster size for sampling (in number of blocks). Set to > 0 if cluster |
| // sampling, 0 otherwise. |
| // |
| Lng32 clusterSize_; |
| |
| // MV -- |
| // These are columns prepared by the TCB during execution and projected |
| // for logging purposes. |
| ValueIdSet extraOutputColumns_; |
| NABoolean isRewrittenMV_; // default is FALSE |
| |
| // see enum ScanFlags |
| ULng32 scanFlags_; |
| |
| // QSTUFF |
| NABoolean embeddedUpdateOrDelete_; |
| // QSTUFF |
| |
| //?johannes? |
| // scan produces a continuous stream without returning an end-of-data |
| NABoolean stream_; |
| |
| // is this scan created by a rule that wants to force a specific index? |
| NABoolean forcedIndexInfo_; |
| |
| // do not apply hints (e.g. used for inner table of index join) |
| NABoolean suppressHints_; |
| |
| // hbase options. Like: number of trafodion row versions to retrieve from hbase. |
| HbaseAccessOptions *hbaseAccessOptions_; |
| |
| // List of MV matches that can be substituted for the SCAN using query rewrite. |
| NAList<MVMatch*> matchingMVs_; |
| |
| // pointer to the common subexpression, if this is a scan of a |
| // materialized common subexpr |
| CommonSubExprRef *commonSubExpr_; |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // FileScan : Physical Operator |
| // |
| // The filescan operator differs from its logical Scan operator in |
| // that selection predicates have been further divided into. |
| // Also, an Index has been attached to it and it is guaranteed to |
| // be an index only scan (the predicates_ are covered by the |
| // attached index columns) |
| // ----------------------------------------------------------------------- |
| |
| // Forward so that FileScan knows about it: |
| class FileScanOptimizer; // declared in ScanOptimizer.h |
| class FileScan : public Scan |
| { |
| public: |
| |
| FileScan(const CorrName& tableName, |
| TableDesc * tableDescPtr, |
| const IndexDesc *indexDescPtr, |
| const NABoolean isReverseScan, |
| const Cardinality& baseCardinality, |
| StmtLevelAccessOptions& accessOptions, |
| GroupAttributes * groupAttributesPtr, |
| const ValueIdSet& selectionPredicates, |
| const Disjuncts& disjuncts, |
| const ValueIdSet &generatedCCPreds, |
| OperatorTypeEnum otype = REL_FILE_SCAN |
| ); |
| |
| FileScan(const CorrName& name, |
| TableDesc * tabId, |
| const IndexDesc *indexDesc, |
| OperatorTypeEnum otype = REL_FILE_SCAN, |
| CollHeap *oHeap = CmpCommon::statementHeap()) |
| : Scan (name, tabId, otype, oHeap), indexDesc_(indexDesc), |
| executorPredTree_(NULL), reverseScan_(FALSE), |
| mdamKeyPtr_(NULL), |
| disjunctsPtr_(NULL), |
| pathKeys_(NULL), |
| partKeys_(NULL), |
| hiveSearchKey_(NULL), |
| numberOfBlocksToReadPerAccess_ (-1), |
| estRowsAccessed_ (0), |
| mdamFlag_(UNDECIDED), |
| skipRowsToPreventHalloween_(FALSE), |
| probes_(0), |
| successfulProbes_(0), |
| uniqueProbes_(0), |
| duplicateSuccProbes_(0), |
| failedProbes_(0), |
| tuplesProcessed_(0), |
| computedNumOfActivePartitions_(-1) |
| {} |
| |
| // destructor |
| virtual ~FileScan() {} |
| |
| // The set of values that I can potentially produce as output. |
| virtual void getPotentialOutputValues(ValueIdSet & vs) const; |
| |
| virtual NABoolean patternMatch(const RelExpr & other) const; |
| virtual NABoolean duplicateMatch(const RelExpr & other) const; |
| virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL, |
| CollHeap* outHeap = 0); |
| |
| // the FileScan node is purely physical |
| virtual NABoolean isLogical() const; |
| virtual NABoolean isPhysical() const; |
| |
| virtual PhysicalProperty *synthPhysicalProperty(const Context *context, |
| const Lng32 planNumber, |
| PlanWorkSpace *pws); |
| |
| PhysicalProperty * synthHiveScanPhysicalProperty(const Context *context, |
| const Lng32 planNumber, |
| ValueIdList &sortOrderVEG); |
| |
| PhysicalProperty * synthHbaseScanPhysicalProperty(const Context *context, |
| const Lng32 planNumber, |
| ValueIdList &sortOrderVEG); |
| |
| // Obtain a pointer to a CostMethod object that provides access |
| // to the cost estimation functions for nodes of this type. |
| virtual CostMethod* costMethod() const; |
| |
| // method to do code generation |
| virtual RelExpr * preCodeGen(Generator * generator, |
| const ValueIdSet & externalInputs, |
| ValueIdSet &pulledNewInputs); |
| virtual short codeGen(Generator*); |
| |
| short codeGenForHive(Generator*); |
| short genForTextAndSeq(Generator * generator, |
| Queue * &hdfsFileInfoList, |
| Queue * &hdfsFileRangeBeginList, |
| Queue * &hdfsFileRangeNumList, |
| char* &hdfsHostName, |
| Int32 &hdfsPort, |
| NABoolean &doMultiCursor, |
| NABoolean &doSplitFileOpt, |
| NABoolean &isHdfsCompressed); |
| static short genForOrc(Generator * generator, |
| const HHDFSTableStats* hTabStats, |
| const PartitioningFunction * mypart, |
| Queue * &hdfsFileInfoList, |
| Queue * &hdfsFileRangeBeginList, |
| Queue * &hdfsFileRangeNumList, |
| char* &hdfsHostName, |
| Int32 &hdfsPort); |
| |
| static TrafDesc *createHbaseTableDesc(const char * table_name); |
| |
| // Return a (short-lived) reference to the respective predicates |
| const ValueIdList & getBeginKeyPred() const { return beginKeyPred_; } |
| const ValueIdList & getEndKeyPred() const { return endKeyPred_; } |
| |
| // executor predicates accessor functions: |
| const ValueIdSet& getExecutorPredicates() const |
| { return executorPredicates_; } |
| void setExecutorPredicates(const ValueIdSet& executorPredicates) |
| { executorPredicates_ = executorPredicates; |
| executorPredicates_ -= getComputedPredicates(); } |
| // Naked access to executorPredicates_ only because there is code |
| // in precodegen that needs this (old code) (don't use this, use |
| // get/set functions above): |
| ValueIdSet& executorPred() { return executorPredicates_; } |
| ItemExpr * getExecutorPredTree() { return executorPredTree_; } |
| ValueIdSet & retrievedCols() { return retrievedCols_; } |
| |
| NABoolean getReverseScan() const { return reverseScan_; } |
| // void setReverseScan(NABoolean rs) { reverseScan_ = rs; } |
| |
| // IndexDesc * indexDesc() { return indexDesc_; } |
| const IndexDesc * getIndexDesc() const { return indexDesc_; } |
| |
| |
| void setIndexDesc (const IndexDesc* idx) {indexDesc_ = idx;} |
| |
| // for code generator who shouldn't access phys. props: |
| const PartitioningFunction *getPartFunc() const; |
| |
| //used to retrieve the operator type |
| virtual const NAString getText() const; |
| //used to retrieve the description |
| virtual const NAString getTypeText() const; |
| |
| inline bool isFullScanPresent()const |
| { |
| if (pathKeys_ && pathKeys_->isFullScanPresent()) |
| return true; |
| return false; |
| } |
| virtual void addLocalExpr(LIST(ExprNode *) &xlist, |
| LIST(NAString) &llist) const; |
| |
| |
| void setSearchKey(SearchKey *searchKeyPtr) |
| { pathKeys_ = searchKeyPtr; } |
| const SearchKey * getSearchKeyPtr() const |
| { return pathKeys_; } |
| const SearchKey * getSearchKey() const |
| { return getSearchKeyPtr(); } |
| |
| // Naked access to pathKeys_ only because there is code |
| // in precodegen that needs this (old code): |
| SearchKey* searchKey() |
| { return pathKeys_; } |
| |
| HivePartitionAndBucketKey * getHiveSearchKey() { return hiveSearchKey_; } |
| void setHiveSearchKey(HivePartitionAndBucketKey *s) { hiveSearchKey_ = s; } |
| |
| // adds Explain information to this node. Implemented in |
| // Generator/GenExplain.C |
| ExplainTuple *addSpecificExplainInfo(ExplainTupleMaster *explainTuple, |
| ComTdb * tdb, |
| Generator *generator); |
| |
| |
| MdamKey* mdamKeyPtr() { return mdamKeyPtr_; } |
| const MdamKey* getMdamKeyPtr() const { return mdamKeyPtr_; } |
| void setMdamKey(MdamKey *mdamKeyPtr) |
| { mdamKeyPtr_ = mdamKeyPtr; } |
| |
| MdamFlags getMdamFlag()const { return mdamFlag_; } |
| void setMdamFlag(MdamFlags mdamFlag) { mdamFlag_ = mdamFlag; } |
| const Disjuncts& getDisjuncts() const; |
| |
| virtual NABoolean okToAttemptESPParallelism ( |
| const Context* myContext, /*IN*/ |
| PlanWorkSpace* pws, /*IN*/ |
| Lng32& numOfESPs, /*OUT*/ |
| float& allowedDeviation, /*OUT*/ |
| NABoolean& numOfESPsForced /*OUT*/) ; |
| |
| virtual void addPartKeyPredsToSelectionPreds( |
| const ValueIdSet& partKeyPreds, |
| const ValueIdSet& pivs); |
| |
| |
| virtual Lng32 getNumberOfBlocksToReadPerAccess() const |
| { |
| // make sure that value has been initialized before using it: |
| CMPASSERT(numberOfBlocksToReadPerAccess_ > -1); |
| return numberOfBlocksToReadPerAccess_; |
| } |
| |
| virtual void setNumberOfBlocksToReadPerAccess(const Lng32& blocks) |
| { |
| DCMPASSERT(blocks > -1); |
| numberOfBlocksToReadPerAccess_ = blocks; |
| } |
| |
| virtual PlanPriority computeOperatorPriority |
| (const Context* context, |
| PlanWorkSpace *pws=NULL, |
| Lng32 planNumber=0); |
| |
| // ----------------------------------------------------- |
| // generate CONTROL QUERY SHAPE fragment for this node. |
| // ----------------------------------------------------- |
| virtual short generateShape(CollHeap * space, char * buf, NAString * shapeStr = NULL); |
| |
| inline const CostScalar getEstRowsAccessed() const |
| { return estRowsAccessed_; } |
| inline void setEstRowsAccessed(CostScalar r) { estRowsAccessed_ = r; } |
| |
| |
| virtual void setSkipRowsToPreventHalloween() |
| { skipRowsToPreventHalloween_ = TRUE; } |
| |
| inline const ValueIdList &minMaxHJColumns() const { return minMaxHJColumns_; } |
| inline void addMinMaxHJColumn(const ValueId &col) { minMaxHJColumns_.insert(col); } |
| |
| CostScalar getProbes() const { return probes_;}; |
| CostScalar getSuccessfulProbes() const { return successfulProbes_; }; |
| CostScalar getUniqueProbes() const { return uniqueProbes_; }; |
| CostScalar getDuplicatedSuccProbes() const { return duplicateSuccProbes_; } |
| CostScalar getFailedProbes() const { return failedProbes_; } |
| CostScalar getTuplesProcessed() const { return tuplesProcessed_; } |
| |
| void setProbes(CostScalar x) { probes_ = x;}; |
| void setSuccessfulProbes(CostScalar x) { successfulProbes_ = x; }; |
| void setUniqueProbes(CostScalar x) { uniqueProbes_ = x; }; |
| void setDuplicatedSuccProbes(CostScalar x) { duplicateSuccProbes_ = x; } |
| void setFailedProbes(CostScalar x) { failedProbes_ = x; } |
| void setTuplesProcessed(CostScalar x) { tuplesProcessed_ = x; } |
| |
| void setDoUseSearchKey(NABoolean x) { doUseSearchKey_ = x; }; |
| NABoolean getDoUseSearchKey() { return doUseSearchKey_ ; }; |
| |
| RangePartitioningFunction* |
| createRangePartFuncForHbaseTableUsingStats( |
| Lng32& partns, |
| const ValueIdSet& partitioningKeyColumns, |
| const ValueIdList& partitioningKeyColumnsList, |
| const ValueIdList& partitioningKeyColumnsOrder); |
| |
| Int32 getComputedNumOfActivePartiions() const { return computedNumOfActivePartitions_; } |
| |
| protected: |
| |
| void setRetrievedCols(const ValueIdSet &retrievedCols) |
| { retrievedCols_ = retrievedCols; } |
| |
| private: |
| |
| |
| //--------------- Disjuncts ------------------- |
| MdamKey *mdamKeyPtr_; |
| const Disjuncts *disjunctsPtr_; |
| // computed predicates that are reflected in the disjuncts |
| // (those are predicates on computed columns that are |
| // computed from regular predicates) |
| |
| //--------------- Search key ---------------- |
| |
| // A key object. It cannot be constant because some of its |
| // members are modified in GenPreCode.C:FileScan:preCodeGen |
| SearchKey * pathKeys_; |
| |
| // a search key for the partitioning key (maybe same as pathKeys_) |
| SearchKey * partKeys_; |
| |
| // For Hive tables, a bit mask of selected Hive partitions and buckets |
| HivePartitionAndBucketKey *hiveSearchKey_; |
| |
| // the index descriptor |
| const IndexDesc *indexDesc_; |
| // scan direction |
| const NABoolean reverseScan_; |
| |
| |
| //--------- Members to be used at code generation: |
| // executor predicates |
| ValueIdSet executorPredicates_; |
| ItemExpr * executorPredTree_; |
| |
| // Columns to be retrieved from filesystem |
| ValueIdSet retrievedCols_; |
| |
| // key predicates |
| ValueIdList beginKeyPred_; |
| ValueIdList endKeyPred_; |
| |
| // helper functions: |
| void init(); |
| |
| // Estimate of number of blocks that DP2 needs to read |
| // per access. This value is passed to DP2 by the executor, |
| // DP2 uses it to decide whether it will do read ahead |
| // or not. |
| // Its value is -1 if uninitialized |
| Lng32 numberOfBlocksToReadPerAccess_; |
| MdamFlags mdamFlag_; |
| |
| // This flag is needed only by EXPLAIN. |
| NABoolean skipRowsToPreventHalloween_; |
| // Estimated number of Dp2 rows accessed. |
| CostScalar estRowsAccessed_; |
| |
| // columns used for min/max hash join optimization |
| ValueIdList minMaxHJColumns_; |
| |
| ///////////////////////////////////////////////////// |
| // probe counts, transfered from ScanOptimizerFileScan |
| ///////////////////////////////////////////////////// |
| |
| // The total number of probes |
| CostScalar probes_; |
| |
| // The total number of probes that return data |
| CostScalar successfulProbes_; |
| |
| // The number of distinct probes (successful and failed) |
| CostScalar uniqueProbes_; |
| |
| // The number of successful probes (successfulProbes_) that |
| // are not unique. duplicateSuccProbes = successfulProbes - |
| // uniqueSuccProbes. |
| CostScalar duplicateSuccProbes_; |
| |
| // the number of probes do not return |
| // data. failedProbes = probes - successfulProbes |
| CostScalar failedProbes_; |
| |
| // total number of tuples processed under 'probes_' probes |
| CostScalar tuplesProcessed_; |
| |
| NABoolean doUseSearchKey_; |
| |
| // number of active partitions computed only from the Range Part Func |
| // and the search key (partKey_) |
| Int32 computedNumOfActivePartitions_; |
| |
| }; // class FileScan |
| |
| |
| class DP2Scan : public FileScan |
| { |
| public: |
| |
| // constructor |
| DP2Scan(const CorrName& tableName, |
| TableDesc * tableDescPtr, |
| const IndexDesc *indexDescPtr, |
| const NABoolean isReverseScan, |
| const Cardinality& baseCardinality, |
| StmtLevelAccessOptions& accessOptions, |
| GroupAttributes * groupAttributesPtr, |
| const ValueIdSet& selectionPredicates, |
| const Disjuncts& disjuncts |
| ); |
| |
| DP2Scan(const CorrName & name, |
| TableDesc *tableDesc, |
| const IndexDesc *indexDesc, |
| OperatorTypeEnum otype = REL_FILE_SCAN) |
| : FileScan (name, tableDesc, indexDesc, otype) |
| { |
| } |
| |
| // Obtain a pointer to a CostMethod object that provides access |
| // to the cost estimation functions for nodes of this type. |
| virtual CostMethod* costMethod() const; |
| }; |
| |
| // ----------------------------------------------------------------------- |
| /*! |
| * \brief HbaseAccess Class. |
| */ |
| // ----------------------------------------------------------------------- |
| |
| // |
| // |
| // At some point of time, we need to revisit the class hierarchy for Scan |
| // HbaseAccess, FileScan. Quite many code in FileScan (such as costing) is |
| // relevant to both HbaseAccess and Hive scan, and yet there are those not |
| // relevant at all (MDAM). A possible new class hierarchy can be as follows. |
| // |
| // Scan -> FileScan(with general cost) -> SQFileScan (SQ specific costing code)-> DP2SCan |
| // -> HiveFileSCan |
| // -> HbaseFileSCan |
| // |
| |
| class HbaseAccess : public FileScan |
| { |
| public: |
| enum AccessType |
| { |
| SELECT_, |
| INSERT_, |
| UPDATE_, |
| DELETE_, |
| COPROC_AGGR_ |
| }; |
| |
| enum SNPType |
| { |
| SNP_NONE, |
| SNP_SUFFIX, |
| SNP_LATEST |
| }; |
| //latest snapshot support -- |
| enum LatestSnpSupportEnum { |
| latest_snp_supported, |
| latest_snp_index_table,// index table not supported with latest snapshot |
| latest_snp_no_snapshot_available,//snapshot not available |
| latest_snp_not_trafodion_table, // not a trafodion table |
| latest_snp_small_table //table is smaller than a certain threshold |
| }; |
| |
| class SortValue |
| { |
| public: |
| SortValue() |
| { |
| }; |
| |
| bool operator < (const SortValue & other ) const |
| { |
| return (str_ < other.str_); |
| } |
| |
| bool operator == (const SortValue & other ) const |
| { |
| return (str_ == other.str_); |
| } |
| |
| NAString str_; |
| ValueId vid_; |
| }; |
| |
| // constructor |
| |
| //! HbaseAccess Constructor |
| HbaseAccess(CorrName &corrName, |
| OperatorTypeEnum otype = REL_HBASE_ACCESS, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| HbaseAccess(CorrName &corrName, |
| TableDesc *tableDesc, |
| IndexDesc *indexDesc, |
| const NABoolean isReverseScan, |
| const Cardinality& baseCardinality, |
| StmtLevelAccessOptions& accessOptions, |
| GroupAttributes * groupAttributesPtr, |
| const ValueIdSet& selectionPredicates, |
| const Disjuncts& disjuncts, |
| const ValueIdSet& generatedCCPreds, |
| OperatorTypeEnum otype = REL_HBASE_ACCESS, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| HbaseAccess(CorrName &corrName, |
| NABoolean isRW, NABoolean isCW, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| HbaseAccess(OperatorTypeEnum otype = REL_HBASE_ACCESS, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| // destructors |
| //! ~HbaseAccess Destructor |
| virtual ~HbaseAccess(); |
| |
| virtual RelExpr *bindNode(BindWA *bindWAPtr); |
| |
| virtual ExplainTuple * addSpecificExplainInfo(ExplainTupleMaster *explainTuple, |
| ComTdb * tdb, |
| Generator *generator); |
| |
| //! getPotentialOutputValues method |
| // a virtual function for computing the potential outputValues |
| virtual void getPotentialOutputValues(ValueIdSet & vs) const; |
| |
| virtual Lng32 numParams() { return 1; } |
| |
| // acessors |
| //! getVirtualTableName method |
| // returns a const char pointer to the name of the virtual Table |
| // should return a CorrName?## |
| virtual const char *getVirtualTableName() |
| { |
| return getTableName().getQualifiedNameObj().getObjectName().data(); |
| } |
| |
| //used to retrieve the operator type |
| virtual const NAString getText() const; |
| |
| //! getArity method |
| // get the degree of this node (it is a leaf op). |
| virtual Int32 getArity() const { return 0; } |
| |
| // mutators |
| |
| //! createVirtualTableDesc method |
| // creates a TrafDesc for the Virtual Table |
| // virtual TrafDesc *createVirtualTableDesc(); |
| static TrafDesc *createVirtualTableDesc(const char * name, |
| NABoolean isRW = FALSE, |
| NABoolean isCW = FALSE, |
| NAArray<HbaseStr> * hbaseKeys = NULL, |
| NAMemory * heap = NULL); |
| |
| static TrafDesc *createVirtualTableDesc(const char * name, |
| NAList<char*> &colNameList, |
| NAList<char*> &colValList); |
| |
| // return TRUE, if col lengths in virtual desc is same as current default values. |
| // return FALSE, if they are different. If they are, caller will clear the cache |
| // and generate a new descriptor. |
| static NABoolean validateVirtualTableDesc(NATable * naTable); |
| |
| NAList<HbaseSearchKey*>& getHbaseSearchKeys() { return listOfSearchKeys_; }; |
| void addSearchKey(HbaseSearchKey* sk) |
| { listOfSearchKeys_.insertAt(listOfSearchKeys_.entries(), sk); }; |
| |
| //! getPotentialOutputValues method |
| // computes the output values the node can generate |
| // Relies on TableValuedFunctions implementation. |
| |
| // determine which columns to retrieve from the file |
| void computeRetrievedCols(); |
| |
| //! preCodeGen method |
| // method to do preCode generation |
| virtual RelExpr * preCodeGen(Generator * generator, |
| const ValueIdSet & externalInputs, |
| ValueIdSet &pulledNewInputs); |
| |
| static short processNonSQHbaseKeyPreds(Generator * generator, |
| ValueIdSet &preds, |
| ListOfUniqueRows &listOfUniqueRows, |
| ListOfRangeRows &listOfRangeRows); |
| |
| static short processSQHbaseKeyPreds(Generator * generator, |
| NAList<HbaseSearchKey*>& searchKeys, |
| ListOfUniqueRows &listOfUniqueRows, |
| ListOfRangeRows &listOfRangeRows); |
| |
| //! codeGen method |
| // virtual method used by the generator to generate the node |
| virtual short codeGen(Generator*); |
| |
| //! copyTopNode |
| // used to create an Almost complete copy of the node |
| virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL, |
| CollHeap* outHeap = 0); |
| |
| //! synthLogProp method |
| // synthesize logical properties |
| virtual void synthLogProp(NormWA * normWAPtr = NULL); |
| |
| //! synthEstLogProp method |
| // used by the compiler to estimate cost |
| virtual void synthEstLogProp(const EstLogPropSharedPtr& inputEstLogProp); |
| |
| //! getText method |
| // used to display the name of the node. |
| // virtual const NAString getText() const; |
| |
| AccessType &accessType() { return accessType_; } |
| |
| NABoolean isRW() { return isRW_; } |
| NABoolean isCW() { return isCW_; } |
| |
| virtual NABoolean isLogical() const { return FALSE; } |
| virtual NABoolean isPhysical() const { return TRUE; } |
| |
| virtual NABoolean isHbaseScan() { return TRUE; } |
| |
| static int createAsciiColAndCastExpr(Generator * generator, |
| const NAType &givenType, |
| ItemExpr *&asciiValue, |
| ItemExpr *&castValue, |
| NABoolean srcIsInt32Varchar = FALSE); |
| |
| static int createAsciiColAndCastExpr2(Generator * generator, |
| ItemExpr * colNode, |
| const NAType &givenType, |
| ItemExpr *&asciiValue, |
| ItemExpr *&castValue, |
| NABoolean alignedFormat = FALSE); |
| |
| // used for hbase map table where data is stored in string format |
| static int createAsciiColAndCastExpr3(Generator * generator, |
| const NAType &givenType, |
| ItemExpr *&asciiValue, |
| ItemExpr *&castValue); |
| |
| static short genRowIdExpr(Generator * generator, |
| const NAColumnArray & keyColumns, |
| NAList<HbaseSearchKey*>& searchKeys, |
| ex_cri_desc * work_cri_desc, |
| const Int32 work_atp, |
| const Int32 rowIdAsciiTuppIndex, |
| const Int32 rowIdTuppIndex, |
| ULng32 &rowIdAsciiRowLen, |
| ExpTupleDesc* &rowIdAsciiTupleDesc, |
| UInt32 &rowIdLength, |
| ex_expr* &rowIdExpr, |
| NABoolean encodeKeys); |
| |
| static short genRowIdExprForNonSQ(Generator * generator, |
| const NAColumnArray & keyColumns, |
| NAList<HbaseSearchKey*>& searchKeys, |
| ex_cri_desc * work_cri_desc, |
| const Int32 work_atp, |
| const Int32 rowIdAsciiTuppIndex, |
| const Int32 rowIdTuppIndex, |
| ULng32 &rowIdAsciiRowLen, |
| ExpTupleDesc* &rowIdAsciiTupleDesc, |
| UInt32 &rowIdLength, |
| ex_expr* &rowIdExpr); |
| |
| static short genListsOfRows(Generator * generator, |
| NAList<HbaseRangeRows> &listOfRangeRows, |
| NAList<HbaseUniqueRows> &listOfUniqueRows, |
| Queue* &tdbListOfRangeRows, |
| Queue* &tdbListOfUniqueRows); |
| |
| static short genColName(Generator * generator, |
| ItemExpr * col_node, |
| char* &colNameInList); |
| |
| static short genListOfColNames(Generator * generator, |
| const IndexDesc * indexDesc, |
| ValueIdList &columnList, |
| Queue* &listOfColNames); |
| |
| static void addReferenceFromItemExprTree(ItemExpr * ie, |
| NABoolean addCol, NABoolean addHBF, |
| ValueIdSet &colRefVIDset); |
| |
| static void addColReferenceFromVIDlist(const ValueIdList &exprList, |
| ValueIdSet &colRefVIDset); |
| |
| static void addReferenceFromVIDset(const ValueIdSet &exprList, |
| NABoolean addCol, NABoolean addHBF, |
| ValueIdSet &colRefVIDset); |
| |
| static void addColReferenceFromRightChildOfVIDarray(ValueIdArray &exprList, |
| ValueIdSet &colRefVIDset); |
| |
| static short createHbaseColId(const NAColumn * nac, |
| NAString &cid, |
| NABoolean isSecondaryIndex = FALSE); |
| |
| static short returnDups(std::vector<SortValue> &myvector, |
| ValueIdList &srcVIDlist, ValueIdList &dupVIDlist); |
| |
| static short createSortValue(ItemExpr * col_node, |
| std::vector<SortValue> &myvector, |
| NABoolean isSecondaryIndex = FALSE); |
| |
| static short sortValues (const ValueIdList &inList, |
| ValueIdList &sortedList, |
| NABoolean isSecondaryIndex = FALSE); |
| |
| static short sortValues (const ValueIdSet &inSet, |
| ValueIdList &sortedList, |
| ValueIdList &srcVIDlist, |
| ValueIdList &dupVIDlist, |
| NABoolean isSecondaryIndex = FALSE); |
| |
| static short sortValues (NASet<NAString> &inSet, |
| NAList<NAString> &sortedList); |
| |
| static NABoolean columnEnabledForSerialization(ItemExpr * colNode); |
| |
| static NABoolean isEncodingNeededForSerialization(ItemExpr * colNode); |
| |
| //const IndexDesc* getIndexDesc() const { return indexDesc_; }; |
| |
| NABoolean &uniqueHbaseOper() { return uniqueHbaseOper_; } |
| NABoolean &uniqueRowsetHbaseOper() { return uniqueRowsetHbaseOper_; } |
| NABoolean uniqueRowsetHbaseOper() const { return uniqueRowsetHbaseOper_; } |
| |
| NABoolean isHbaseFilterPred(Generator * generator, ItemExpr * ie, |
| ValueId &colVID, ValueId &valueVID, |
| NAString &op, |
| NABoolean &removeFromOrigList); |
| |
| short extractHbaseFilterPreds(Generator * generator, ValueIdSet &preds, |
| ValueIdSet &newExePreds); |
| |
| NABoolean isHbaseFilterPredV2(Generator * generator, ItemExpr * ie, |
| ValueId &colVID, ValueId &valueVID, |
| NAString &op); |
| |
| short extractHbaseFilterPredsVX(Generator * generator,ValueIdSet &preds, ValueIdSet &newExePreds); |
| |
| NABoolean extractHbaseFilterPredsV2(Generator * generator, ValueIdSet &preds, ValueIdSet &newExePreds, |
| NABoolean checkOnly); |
| |
| NABoolean isSnapshotScanFeasible(LatestSnpSupportEnum snpNotSupported, |
| char * tableName); |
| |
| protected: |
| |
| // The search keys built during optimization. |
| NAList<HbaseSearchKey*> listOfSearchKeys_; |
| |
| ListOfUniqueRows listOfUniqueRows_; |
| ListOfRangeRows listOfRangeRows_; |
| |
| //! HbaseAccess Copy Constructor |
| // Copy constructor without heap is not implemented nor allowed. |
| HbaseAccess(const HbaseAccess &other); |
| |
| //CorrName corrName_; |
| |
| AccessType accessType_; |
| |
| ItemExpr * rowIdCast_; |
| |
| NABoolean isRW_; |
| NABoolean isCW_; |
| |
| // list of columns that need to be retrieved from hbase. These are used |
| // in executor preds, update/merge expressions or returned back as output |
| // values. |
| ValueIdSet retColRefSet_; |
| |
| NASet<NAString> retHbaseColRefSet_; |
| |
| NABoolean uniqueHbaseOper_; |
| NABoolean uniqueRowsetHbaseOper_; |
| |
| // these lists are populated during the preCodeGen phase. |
| ValueIdList hbaseFilterColVIDlist_; |
| ValueIdList hbaseFilterValueVIDlist_; |
| NAList<NAString> opList_; |
| SNPType snpType_; |
| |
| }; // class HbaseAccess |
| |
| // NOTE: this class is currently not being used. |
| class HbaseAccessCoProcAggr : public HbaseAccess |
| { |
| public: |
| HbaseAccessCoProcAggr(CorrName &corrName, |
| ValueIdSet &aggrExpr, |
| TableDesc *tableDesc, |
| IndexDesc *indexDesc, |
| const NABoolean isReverseScan, |
| const Cardinality& baseCardinality, |
| StmtLevelAccessOptions& accessOptions, |
| GroupAttributes * groupAttributesPtr, |
| const ValueIdSet& selectionPredicates, |
| const Disjuncts& disjuncts, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| HbaseAccessCoProcAggr(CorrName &corrName, |
| ValueIdSet &aggrExpr, |
| CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| HbaseAccessCoProcAggr(CollHeap *oHeap = CmpCommon::statementHeap()); |
| |
| // destructors |
| //! ~HbaseAccess Destructor |
| virtual ~HbaseAccessCoProcAggr(); |
| |
| virtual RelExpr *bindNode(BindWA *bindWAPtr); |
| |
| //used to retrieve the operator type |
| virtual const NAString getText() const; |
| |
| // method to do preCode generation |
| virtual RelExpr * preCodeGen(Generator * generator, |
| const ValueIdSet & externalInputs, |
| ValueIdSet &pulledNewInputs); |
| |
| //! codeGen method |
| // virtual method used by the generator to generate the node |
| virtual short codeGen(Generator*); |
| |
| //! copyTopNode |
| // used to create an Almost complete copy of the node |
| virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL, |
| CollHeap* outHeap = 0); |
| |
| virtual void getPotentialOutputValues(ValueIdSet & outputValues) const; |
| |
| virtual PhysicalProperty *synthPhysicalProperty(const Context *context, |
| const Lng32 planNumber, |
| PlanWorkSpace *pws); |
| |
| virtual NABoolean isLogical() const { return TRUE; } |
| virtual NABoolean isPhysical() const { return TRUE; } |
| |
| ValueIdSet &aggregateExpr() { return aggregateExpr_; } |
| const ValueIdSet &aggregateExpr() const { return aggregateExpr_; } |
| protected: |
| |
| // list of columns that need to be retrieved from hbase. These are used |
| // in executor preds, update/merge expressions or returned back as output |
| // values. |
| ValueIdSet aggregateExpr_; |
| |
| }; // class HbaseAccessCoProcAggr |
| |
| // ----------------------------------------------------------------------- |
| // The Describe class represents scan on a 'virtual' table that contains |
| // the output of the DESCRIBE(SHOWDDL) command. |
| // ----------------------------------------------------------------------- |
| class Describe : public Scan |
| { |
| public: |
| enum Format |
| { |
| INVOKE_, // describe sql/mp INVOKE style |
| SHOWSTATS_, //display histograms for specified table |
| SHORT_, // just show ddl for table |
| SHOWDDL_, // show everything about this table (ddl, indexes, views, etc) |
| PLAN_, // return information about runtime plan. Currently, details |
| // about expressions and clauses are the only info returned. |
| // For internal debugging use only. Not externalized to users. |
| LABEL_, // For showlabel |
| SHAPE_, // For SHOWSHAPE. Generates a CONTROL QUERY SHAPE statement for |
| // the given query. |
| TRANSACTION_, // display current transaction settings in effect for |
| // those items that can be set by a SET TRANSACTION statement. |
| SET_, // For SHOWSET. Shows all runtime SET stmts in effect. |
| ENVVARS_, // For 'get envvars'. Shows all envvars in effect. |
| |
| // show the corresponding control options that are in effect. |
| CONTROL_FIRST_, |
| CONTROL_ALL_ = CONTROL_FIRST_, |
| CONTROL_SHAPE_, |
| CONTROL_DEFAULTS_, |
| CONTROL_TABLE_, |
| CONTROL_SESSION_, |
| CONTROL_LAST_ = CONTROL_SESSION_, |
| |
| LEAKS_, // For SHOWLEAKS. |
| STATIC_PLAN_,// same as PLAN_ but from static pre-compiled programs. |
| // Not externalized. |
| SHOWQRYSTATS_ // display histograms for specified query |
| }; |
| enum ShowcontrolOption |
| { |
| MATCH_FULL_, |
| MATCH_FULL_NO_HEADER_, // internal option, meant for use by utilities |
| MATCH_PARTIAL_, |
| MATCH_NONE_ |
| }; |
| |
| // -------------------------------------------------------------------------- |
| // Note: Parser passes in value UR of parameter labelAnsiNameSpace for |
| // procedures if the keyword PROCEDURE is specified, even though the valid |
| // namespace value of the procedure is TA. SHOWDDL has been changed to |
| // no longer rely on the PROCEDURE keyword to support stored procedures. |
| // -------------------------------------------------------------------------- |
| |
| Describe(char * originalQuery, |
| const CorrName &describedTableName, |
| Format format = SHOWDDL_, |
| ComAnsiNameSpace labelAnsiNameSpace = COM_TABLE_NAME, |
| ULng32 flags = 0, |
| NABoolean header = TRUE) |
| : Scan(REL_DESCRIBE), |
| describedTableName_(describedTableName, CmpCommon::statementHeap()), |
| pUUDFName_(NULL), |
| format_(format), |
| labelAnsiNameSpace_(labelAnsiNameSpace), // See comments above |
| flags_(flags), |
| header_(header), // header = FALSE will produce showcontrol output with |
| // any header information. This option will be used by |
| //utilities and is not externalised. |
| isSchema_(false), |
| toTryPublicSchema_(false), |
| authIDClass_(COM_UNKNOWN_ID_CLASS), |
| isComponent_(false) |
| { |
| setNonCacheable(); |
| if (originalQuery) |
| { |
| originalQuery_ = new (CmpCommon::statementHeap()) |
| char[strlen(originalQuery)+1]; |
| strcpy(originalQuery_, originalQuery); |
| } |
| else |
| originalQuery_ = NULL; |
| } |
| |
| Describe(char * originalQuery, |
| const SchemaName &schemaName, |
| Format format = SHOWDDL_, |
| ULng32 flags = 0, |
| NABoolean header = TRUE) |
| : Scan(REL_DESCRIBE), |
| describedTableName_("", CmpCommon::statementHeap()), |
| pUUDFName_(NULL), |
| schemaQualName_(schemaName, CmpCommon::statementHeap()), |
| format_(format), |
| flags_(flags), |
| header_(header), // header = FALSE will produce showcontrol output with |
| // any header information. This option will be used by |
| //utilities and is not externalised. |
| isSchema_(true), |
| toTryPublicSchema_(false), |
| authIDClass_(COM_UNKNOWN_ID_CLASS), |
| isComponent_(false) |
| { |
| setNonCacheable(); |
| if (originalQuery) |
| { |
| originalQuery_ = new (CmpCommon::statementHeap()) |
| char[strlen(originalQuery)+1]; |
| strcpy(originalQuery_, originalQuery); |
| } |
| else |
| originalQuery_ = NULL; |
| |
| if (schemaQualName_.getCatalogName().isNull()) |
| schemaQualName_.setCatalogName( |
| ActiveSchemaDB()->getDefaultSchema().getCatalogName()); |
| |
| schemaName_ = ToAnsiIdentifier(schemaQualName_.getCatalogName()) + "." + |
| ToAnsiIdentifier(schemaQualName_.getSchemaName()); |
| |
| CorrName temp(schemaQualName_.getSchemaName(),CmpCommon::statementHeap(), |
| schemaQualName_.getSchemaName(),schemaQualName_.getCatalogName()); |
| |
| describedTableName_ = temp; |
| } |
| // constructor used for SHOWDDL USER and SHOWDDL ROLE |
| Describe(char * originalQuery, |
| ComIdClass authIDClass, |
| const NAString &authIDName, |
| Format format = SHOWDDL_, |
| ULng32 flags = 0, |
| NABoolean header = TRUE) |
| : Scan(REL_DESCRIBE), |
| describedTableName_("", CmpCommon::statementHeap()), |
| pUUDFName_(NULL), |
| schemaQualName_("", CmpCommon::statementHeap()), |
| format_(format), |
| flags_(flags), |
| header_(header), // header = FALSE will produce showcontrol output with |
| // any header information. This option will be used by |
| //utilities and is not externalised. |
| isSchema_(false), |
| toTryPublicSchema_(false), |
| labelAnsiNameSpace_(COM_UNKNOWN_NAME), |
| authIDClass_ (authIDClass), |
| authIDName_(authIDName), |
| isComponent_(false) |
| { |
| setNonCacheable(); |
| if (originalQuery) |
| { |
| originalQuery_ = new (CmpCommon::statementHeap()) |
| char[strlen(originalQuery)+1]; |
| strcpy(originalQuery_, originalQuery); |
| } |
| else |
| originalQuery_ = NULL; |
| } |
| |
| // constructor used for SHOWDDL USER and SHOWDDL ROLE |
| Describe(char * originalQuery, |
| const NAString &componentName, |
| Format format = SHOWDDL_, |
| ULng32 flags = 0, |
| NABoolean header = TRUE) |
| : Scan(REL_DESCRIBE), |
| describedTableName_("", CmpCommon::statementHeap()), |
| pUUDFName_(NULL), |
| schemaQualName_("", CmpCommon::statementHeap()), |
| format_(format), |
| flags_(flags), |
| header_(header), // header = FALSE will produce showcontrol output with |
| // any header information. This option will be used by |
| //utilities and is not externalised. |
| isSchema_(false), |
| toTryPublicSchema_(false), |
| labelAnsiNameSpace_(COM_UNKNOWN_NAME), |
| authIDClass_ (COM_UNKNOWN_ID_CLASS), |
| componentName_(componentName), |
| isComponent_(true) |
| { |
| setNonCacheable(); |
| if (originalQuery) |
| { |
| originalQuery_ = new (CmpCommon::statementHeap()) |
| char[strlen(originalQuery)+1]; |
| strcpy(originalQuery_, originalQuery); |
| } |
| else |
| originalQuery_ = NULL; |
| } |
| |
| ~Describe() { delete originalQuery_; delete pUUDFName_; } |
| |
| virtual RelExpr * bindNode(BindWA *bindWAPtr); |
| |
| // this is both logical and physical node |
| virtual NABoolean isLogical() const {return TRUE;} |
| virtual NABoolean isPhysical() const {return TRUE;} |
| |
| // The set of values that I can potentially produce as output. |
| virtual void getPotentialOutputValues(ValueIdSet & vs) const; |
| |
| // cost functions |
| virtual PhysicalProperty *synthPhysicalProperty(const Context *context, |
| const Lng32 planNumber, |
| PlanWorkSpace *pws); |
| |
| // method to do code generation |
| virtual short codeGen(Generator*); |
| |
| // various PC methods |
| |
| // get the degree of this node (it is a leaf op). |
| virtual Int32 getArity() const {return 0;} |
| virtual RelExpr * copyTopNode(RelExpr *derivedNode = NULL, |
| CollHeap* outHeap = 0); |
| virtual const NAString getText() const; |
| |
| const CorrName &getDescribedTableName() const |
| { |
| return describedTableName_; |
| } |
| |
| Format getFormat() const {return format_;} |
| |
| NABoolean getIsBrief() const |
| { |
| return (flags_ & 0x00000008); |
| } |
| |
| NABoolean getIsDetail() const |
| { |
| return (flags_ & 0x00000004); |
| } |
| |
| NABoolean getIsExternal() const |
| { |
| return (flags_ & 0x00000020); |
| } |
| |
| NABoolean getIsInternal() const |
| { |
| return (flags_ & 0x00000040); |
| } |
| |
| NABoolean getIsSchema() const |
| { |
| return isSchema_; |
| } |
| |
| NABoolean getIsUser() const |
| { |
| return (authIDClass_ == COM_USER_CLASS); |
| } |
| |
| NABoolean getIsRole() const |
| { |
| return (authIDClass_ == COM_ROLE_CLASS); |
| } |
| |
| NABoolean getIsComponent() const |
| { |
| return isComponent_; |
| } |
| |
| ComAnsiNameSpace getLabelAnsiNameSpace() const |
| { |
| return labelAnsiNameSpace_; |
| } |
| |
| NABoolean getIsControl() const { return ((getFormat() >= CONTROL_FIRST_) && |
| (getFormat() <= CONTROL_LAST_)); } |
| |
| // TRUE => output detail (long) label info |
| // FALSE => output short label info |
| NABoolean getLabelDetail() const |
| { |
| return (flags_ & 0x00000001); |
| } |
| void setLabelDetail(const NABoolean wantDetail) |
| { |
| if(wantDetail) |
| flags_ = flags_ | 0x00000001; |
| else |
| flags_ = flags_ & 0xFFFFFFFE; |
| } |
| |
| |
| NABoolean getDisplayPrivileges() const |
| { |
| return (flags_ & 0x00000010); |
| } |
| |
| NABoolean getDisplayPrivilegesOnly() const |
| { |
| return (flags_ & 0x00000080); |
| } |
| |
| NABoolean getDisplaySynonymsOnly() const |
| { |
| return (flags_ & 0x00000100); |
| } |
| |
| void setLabelAnsiNameSpace(const ComAnsiNameSpace nameSpace) |
| { |
| labelAnsiNameSpace_ = nameSpace; |
| } |
| |
| ULng32 getFlags() const |
| { |
| return flags_; |
| } |
| void setFlags(const ULng32 flags) |
| { |
| flags_ = flags; |
| } |
| |
| NABoolean getHeader() const |
| { |
| return header_; |
| } |
| |
| const SchemaName& getSchemaQualifiedName() const |
| { |
| return schemaQualName_; |
| } |
| |
| const NAString& getSchemaName() const |
| { |
| return schemaName_; |
| } |
| |
| const NAString& getAuthIDName() const |
| { |
| return authIDName_; |
| } |
| |
| const NAString& getComponentName() const |
| { |
| return componentName_; |
| } |
| |
| NABoolean toTryPublicSchema() const |
| { |
| return toTryPublicSchema_; |
| } |
| |
| void setToTryPublicSchema(const NABoolean val) |
| { |
| toTryPublicSchema_=val; |
| } |
| |
| void setDescribedTableSchema(const NAString cat, const NAString sch) |
| { |
| describedTableName_.getQualifiedNameObj().setCatalogName(cat); |
| describedTableName_.getQualifiedNameObj().setSchemaName(sch); |
| } |
| |
| const QualifiedName * getUudfQualNamePtr() const |
| { |
| return pUUDFName_; |
| } |
| |
| QualifiedName * getUudfQualNamePtr() |
| { |
| return pUUDFName_; |
| } |
| |
| const QualifiedName & getUudfQualName() const |
| { |
| if (pUUDFName_ EQU NULL) |
| { |
| const_cast<Describe*>(this)->pUUDFName_ = |
| new (STMTHEAP) QualifiedName(STMTHEAP); |
| } |
| return *pUUDFName_; |
| } |
| |
| QualifiedName & getUudfQualName() |
| { |
| if (pUUDFName_ EQU NULL) |
| pUUDFName_ = new (STMTHEAP) QualifiedName(STMTHEAP); |
| return *pUUDFName_; |
| } |
| |
| void setUudfQualNamePtr(QualifiedName * pUudfQualName) // shallow copy |
| { |
| pUUDFName_ = pUudfQualName; // shallow copy |
| // pUudfQualName should point to a QualifiedName object |
| // allocated in the PARSERHEAP(). pUUDFName_ is only used |
| // with SHOWDDL ACTION <action-qual-name> ON UNIVERSAL |
| // FUNCTION <uudf-qual-name> ... syntax. |
| } |
| |
| void setUudfQualName(const QualifiedName & src) // deep copy |
| { |
| if (pUUDFName_ EQU NULL) |
| pUUDFName_ = new (STMTHEAP) QualifiedName(STMTHEAP); |
| *pUUDFName_ = src; |
| } |
| |
| NABoolean maybeInMD() const |
| { |
| return ( |
| format_ == INVOKE_ || |
| format_ == SHOWSTATS_ || |
| format_ == SHORT_ || |
| format_ == SHOWDDL_ || |
| format_ == LABEL_) ; |
| } |
| |
| private: |
| CorrName describedTableName_; |
| // pUUDFName_ is only used when describedTableName_ contains a routine action |
| QualifiedName *pUUDFName_; |
| |
| Format format_; |
| |
| char * originalQuery_; |
| |
| // used for SHOWLABEL |
| ComAnsiNameSpace labelAnsiNameSpace_; |
| |
| ULng32 flags_; |
| |
| NABoolean header_; |
| NABoolean isSchema_; |
| SchemaName schemaQualName_; |
| NAString schemaName_; |
| NABoolean toTryPublicSchema_; |
| |
| // Added for SHOWDDL USER & SHOWDDL ROLE |
| ComIdClass authIDClass_; |
| NAString authIDName_; |
| |
| // Added for SHOWDDL component |
| NABoolean isComponent_; |
| NAString componentName_; |
| |
| // copy ctor |
| Describe (const Describe & des) ; // not defined - DO NOT USE |
| }; // class Describe |
| |
| #endif /* RELSCAN_H */ |
