| /********************************************************************** |
| // @@@ 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 INDEXDESC_H |
| #define INDEXDESC_H |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: IndexDesc.h |
| * Description: Index descriptors (an IndexDesc is to an index what |
| * a TableDesc is to a base table) |
| * |
| * Created: 4/21/95 |
| * Language: C++ |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| // ----------------------------------------------------------------------- |
| |
| #include "NABasicObject.h" |
| |
| // ----------------------------------------------------------------------- |
| // contents of this file |
| // ----------------------------------------------------------------------- |
| class IndexDesc; |
| |
| // ----------------------------------------------------------------------- |
| // forward declarations |
| // ----------------------------------------------------------------------- |
| class TableDesc; |
| class NATable; |
| class NAFileSet; |
| class PartitioningFunction; |
| class NAColumnArray; |
| class CmpContext; |
| class FileScanCostList; |
| class AccessPathAnalysis; |
| #ifndef MDAM_FLAGS |
| #define MDAM_FLAGS |
| enum MdamFlags { UNDECIDED, |
| MDAM_ON, |
| MDAM_OFF |
| }; |
| #endif |
| #ifndef INDEX_JOIN_SLECTIVITY |
| #define INDEX_JOIN_SLECTIVITY |
| enum IndexJoinSelectivityEnum { |
| INDEX_ONLY_INDEX, |
| INDEX_JOIN_VIABLE, |
| EXCEEDS_BT_SCAN |
| }; |
| #endif |
| // ----------------------------------------------------------------------- |
| // An IndexDesc contains value ids for the columns of an index and for |
| // its key and its ordering. Like a TableDesc mirrors the information |
| // contained in an NATable object, an IndexDesc mirrors the information |
| // contained in an NAFileSet object. |
| // ----------------------------------------------------------------------- |
| class IndexDesc : public NABasicObject |
| { |
| |
| public: |
| |
| IndexDesc(TableDesc *tdesc, NAFileSet *fileSet, CmpContext* context); |
| |
| // accessor functions |
| const QualifiedName& getIndexName() const; |
| const NAString& getExtIndexName() const; |
| |
| Lng32 getRecordLength() const; |
| Lng32 getKeyLength() const; |
| Lng32 getIndexLevels() const { return indexLevels_; } |
| |
| const NAColumnArray & getAllColumns() const; |
| |
| const ValueIdList & getIndexColumns() const { return indexColumns_; } |
| const ValueIdList & getIndexKey() const { return indexKey_; } |
| |
| // return the set of index columns that are not part of |
| // the key: |
| void getNonKeyColumnSet(ValueIdSet& nonKeyColumnSet) const; |
| |
| // return the list of index columns that are not part of the key: |
| void getNonKeyColumnList(ValueIdList& nonKeyColumnList) const; |
| |
| const ValueIdList & getOrderOfKeyValues() const { return orderOfKeyValues_; } |
| const ValueIdList & getPartitioningKey() const { return partitioningKey_; } |
| |
| const ValueIdList & getOrderOfPartitioningKeyValues() const |
| { return orderOfPartitioningKeyValues_; } |
| |
| void setIndexLevels(Lng32 indexLevels) { indexLevels_ = indexLevels ; } |
| void setOrderOfKeyValues(const ValueIdList &no) { orderOfKeyValues_ = no; } |
| |
| NABoolean containsClusteringKey() const |
| { return clusteringKey_.entries() > 0; } |
| |
| const ValueIdList & getClusteringKeyCols() const |
| { return clusteringKey_; } |
| |
| PartitioningFunction * getPartitioningFunction() const |
| { return partFunc_; } |
| |
| NABoolean isClusteringIndex() const { return clusteringIndexFlag_; } |
| |
| const NAFileSet * getNAFileSet() const { return fileSet_; } |
| |
| TableDesc *getPrimaryTableDesc() const { return tableDesc_; } |
| |
| MdamFlags pruneMdam(const ValueIdSet& preds, |
| NABoolean indexOnlyIndex, |
| IndexJoinSelectivityEnum& selectivityEnum, |
| const GroupAttributes * groupAttr = NULL, |
| const ValueIdSet * inputValues = NULL) const; |
| NABoolean isUniqueIndex() const; |
| |
| // Partitioning |
| NABoolean isPartitioned() const; |
| |
| // mutator functions |
| void markAsClusteringIndex() { clusteringIndexFlag_ = TRUE; } |
| |
| // Is it recommended by user hint, and what delta to use |
| int indexHintPriorityDelta() const; |
| |
| // On return: |
| // the amount of data that the local predicate will produce, when |
| // table analysis is performed and all stats on the referenced |
| // columns are available and not faked; |
| // -1; otherwise. |
| // |
| CostScalar getKbForLocalPred() const; |
| |
| // new methods added for costing purposes: |
| CostScalar getKbPerVolume() const; |
| CostScalar getRecordSizeInKb() const; |
| CostScalar getBlockSizeInKb() const; |
| CostScalar getEstimatedRecordsPerBlock() const; |
| CostScalar getEstimatedIndexBlocksLowerBound(const CostScalar& probes) const; |
| |
| // new access method added for reusing simple cost vectors |
| FileScanCostList * getBasicCostList() const {return scanBasicCosts_;} |
| |
| void setBasicCostList(FileScanCostList * basicCosts ) |
| { scanBasicCosts_ = basicCosts; } |
| |
| AccessPathAnalysis * getAccessPathAnalysis() const {return accessPathAnalysis_;} |
| void setAccessPathAnalysis(AccessPathAnalysis * accessPath) |
| { accessPathAnalysis_ = accessPath;} |
| |
| // --------------------------------------------------------------------- |
| // Print/debug |
| // --------------------------------------------------------------------- |
| virtual void print( FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "IndexDesc"); |
| |
| // ----------------------------------------------------------------------- |
| // get the working heap, this heap is expected to be cleanup at the end |
| // of statement. |
| // ----------------------------------------------------------------------- |
| CollHeap* wHeap(); |
| |
| private: |
| |
| // A pointer to the table descriptor for the base table. |
| // |
| TableDesc *tableDesc_; |
| |
| // --------------------------------------------------------------------- |
| // The number of levels in the index between the root and a leaf page. |
| // If the root is one level from the leaf then indexLevel_ is set to 1. |
| // --------------------------------------------------------------------- |
| Lng32 indexLevels_; |
| |
| // --------------------------------------------------------------------- |
| // all columns (index key and non-key columns) of the index |
| // --------------------------------------------------------------------- |
| ValueIdList indexColumns_; |
| |
| // --------------------------------------------------------------------- |
| // the value ids that comprise the key of the index file |
| // --------------------------------------------------------------------- |
| ValueIdList indexKey_; |
| |
| // --------------------------------------------------------------------- |
| // a list of expressions by which the index file is ordered |
| // usually same as indexKey_, except for descending order |
| // --------------------------------------------------------------------- |
| ValueIdList orderOfKeyValues_; |
| |
| // --------------------------------------------------------------------- |
| // the value ids that comprise the partitioning key of the index file |
| // --------------------------------------------------------------------- |
| ValueIdList partitioningKey_; |
| |
| // --------------------------------------------------------------------- |
| // a list of expressions by which the index file is partitioned |
| // usually same as partitioningKey_, except for descending order |
| // --------------------------------------------------------------------- |
| ValueIdList orderOfPartitioningKeyValues_; |
| |
| // --------------------------------------------------------------------- |
| // The value ids of the IndexColumn exprs that form the clustering key |
| // or an empty list, if the clustering key isn't part of the index |
| // --------------------------------------------------------------------- |
| ValueIdList clusteringKey_; |
| |
| // --------------------------------------------------------------------- |
| // Flag for indicating whether this is a clustering index. |
| // --------------------------------------------------------------------- |
| NABoolean clusteringIndexFlag_; |
| |
| // --------------------------------------------------------------------- |
| // Partitioning function, if the index is horizontally partitioned. |
| // --------------------------------------------------------------------- |
| PartitioningFunction * partFunc_; |
| |
| // --------------------------------------------------------------------- |
| // a pointer to the schema information |
| // --------------------------------------------------------------------- |
| NAFileSet * fileSet_; |
| |
| // ----------------------------------------------------------------------- |
| // a pointer to current CmpContext, containing the global info |
| // ----------------------------------------------------------------------- |
| CmpContext* cmpContext_; |
| |
| // ----------------------------------------------------------------------- |
| // a pointer to list of basic cost objects to reuse in FileScanOptimizer |
| // ----------------------------------------------------------------------- |
| FileScanCostList * scanBasicCosts_; |
| |
| // ----------------------------------------------------------------------- |
| // a pointer to Acess Path Analysis (generated in the amalyzer) |
| // ----------------------------------------------------------------------- |
| AccessPathAnalysis * accessPathAnalysis_; |
| |
| }; |
| |
| #endif |