| /********************************************************************** |
| // @@@ 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 OBJECTNAMES_H |
| #define OBJECTNAMES_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: ObjectNames.h |
| * Description: External SQL object names |
| * Created: 4/27/94 |
| * Language: C++ |
| * |
| * |
| * I am bound to call upon you; |
| * And I pray you, your name? |
| * -- Duke Vincentio, Measure for Measure, III:ii |
| * |
| ****************************************************************************** |
| */ |
| |
| #include <time.h> |
| #include <sys/time.h> |
| |
| #include "CmpCommon.h" |
| #include "NAString.h" |
| #include "NAStringDef.h" |
| #include "charinfo.h" |
| #include "ComMisc.h" |
| |
| // ----------------------------------------------------------------------- |
| // forward declarations |
| // ----------------------------------------------------------------------- |
| |
| class BindWA; |
| class ComObjectName; |
| class HostVar; |
| class ColumnDescList; |
| class RETDesc; |
| |
| // ----------------------------------------------------------------------- |
| // contents of this file |
| // ----------------------------------------------------------------------- |
| |
| class CatalogName; |
| class SchemaName; |
| class QualifiedName; |
| class CorrName; |
| class PartitionClause; |
| class ExtendedQualName; |
| class ColRefName; |
| class TableRefName; |
| class ObjectCounter; |
| class TaskMonitor; |
| |
| // ----------------------------------------------------------------------- |
| // Helpful Definitions. Moved here from StmtDDLNode.h |
| // ----------------------------------------------------------------------- |
| typedef LIST(const NAString *) ConstStringList; |
| |
| // ----------------------------------------------------------------------- |
| // Function GetAnsiNameCharSet() returns the character set attribute |
| // of the ANSI SQL names returned by the methods declared in this |
| // header file (and many others like those in w:/smdio, etc.) |
| // ----------------------------------------------------------------------- |
| |
| #define OBJECTNAMECHARSET ((CharInfo::CharSet)ComGetNameInterfaceCharSet()) |
| |
| CharInfo::CharSet GetAnsiNameCharSet(); |
| |
| // ----------------------------------------------------------------------- |
| // Catalog name |
| // ----------------------------------------------------------------------- |
| class CatalogName : public NABasicObject |
| { |
| |
| public: |
| |
| // constructors |
| CatalogName(const NAString & catalogName = "", |
| CollHeap * h=0, |
| StringPos namePos = 0) : |
| catalogName_(catalogName, h), |
| isDelimited_(FALSE) |
| { if (catalogName.isNull() && namePos == 0) namePos_ = 0; |
| else |
| { |
| setNamePosition(namePos,FALSE); |
| } |
| } |
| |
| // copy ctor |
| CatalogName (const CatalogName & cat, NAMemory * h) : |
| catalogName_(cat.catalogName_, h), |
| namePos_(cat.namePos_), |
| isDelimited_(cat.isDelimited_) |
| {} |
| |
| // accessors |
| const NAString& getCatalogName() const { return catalogName_; } |
| const NAString getCatalogNameAsAnsiString() const |
| { return ToAnsiIdentifier(catalogName_); } |
| StringPos getNamePosition() const { return namePos_; } |
| |
| // Method isDelimited() is implemented enough to solve all the cases |
| // of Genesis 10-970902-0878, but no further. |
| // |
| // Additional setNamePosition() or setIsDelimited() calls would need to be |
| // made in SqlParser.y to have this return TRUE in all other cases of |
| // a one-part identifier (CorrName or ColRefName), |
| // and more work still here in ObjectNames.* for multi-part names. |
| // |
| NABoolean isDelimited() const { return isDelimited_; } |
| |
| // mutators |
| void setCatalogName(const NAString &catName) { catalogName_ = catName; } |
| void setNamePosition(StringPos namePos, NABoolean setDelimited = TRUE); |
| |
| // Display/print, for debugging. |
| void display() const; |
| virtual void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "CatalogName") const; |
| protected: |
| |
| void setIsDelimited(NABoolean isDelimited) { isDelimited_ = isDelimited; } |
| NAString catalogName_; |
| StringPos namePos_; |
| NABoolean isDelimited_; |
| |
| }; // CatalogName |
| |
| // ----------------------------------------------------------------------- |
| // Schema names |
| // |
| // A schema name is used to identify a SQL schema. It consists of |
| // a one or two part name, [ catalog . ] schema. |
| // ----------------------------------------------------------------------- |
| class SchemaName : public CatalogName |
| { |
| |
| public: |
| |
| // constructors |
| |
| SchemaName (CollHeap * h) : |
| CatalogName("",h), |
| schemaName_(h) |
| {} |
| |
| SchemaName(const NAString & schemaName = "", |
| const NAString & catalogName = "", |
| CollHeap * h=0, |
| StringPos namePos = 0) : |
| CatalogName(catalogName, h, namePos), |
| schemaName_(schemaName, h) |
| { CMPASSERT(getCatalogName().isNull() OR NOT getSchemaName().isNull()); |
| } |
| |
| // copy ctor |
| SchemaName (const SchemaName & sch, NAMemory * h) : |
| CatalogName(sch, h), |
| schemaName_(sch.schemaName_, h) |
| {} |
| |
| // accessors |
| const NAString& getSchemaName() const { return schemaName_; } |
| const NAString getSchemaNameAsAnsiString() const; |
| const NAString getUnqualifiedSchemaNameAsAnsiString() const |
| { return ToAnsiIdentifier(schemaName_); } |
| |
| // Translate Trafodion to Hive schema |
| void getHiveSchemaName(NAString &hiveSchemaName) const; |
| |
| // mutator |
| void setSchemaName(const NAString &schName) { schemaName_ = schName; } |
| |
| // Display/print, for debugging. |
| virtual void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "SchemaName") const; |
| |
| // for DEFAULT_SCHEMA_ACCESS_ONLY |
| NABoolean matchDefaultPublicSchema(); |
| |
| protected: |
| |
| NAString schemaName_; |
| |
| }; // SchemaName |
| |
| // ----------------------------------------------------------------------- |
| // Qualified names |
| // |
| // A qualified name is used to identify a SQL object. It consists of |
| // a one, two, or three part name, [ [ catalog . ] schema . ] object. |
| // ----------------------------------------------------------------------- |
| class QualifiedName : public SchemaName |
| { |
| |
| public: |
| |
| // constructors |
| // |
| // CenterLine C++ won't handle const parameters with defaults, so |
| // const NAString &objectName = "", |
| // won't work. |
| // Likewise, c89 can't disambiguate (for no good reason!) the ctor |
| // if the first parameter has a default. |
| // |
| QualifiedName(CollHeap * h=0) : |
| SchemaName(h), |
| objectName_(h), |
| objectNameSpace_(COM_UNKNOWN_NAME), |
| flagbits_(0) |
| {} |
| |
| QualifiedName(const NAString & objectName /* = "" */ , |
| const NAString & schemaName = "", |
| const NAString & catalogName = "", |
| CollHeap * h=0, |
| StringPos namePos = 0) : |
| SchemaName(schemaName, catalogName, h, namePos), |
| objectName_(objectName, h), |
| objectNameSpace_(COM_UNKNOWN_NAME), |
| flagbits_(0) |
| {} |
| |
| QualifiedName(const NAString & ansiString, |
| Int32 minNameParts, |
| CollHeap * h=0, |
| BindWA *bindWA = NULL); |
| |
| QualifiedName(const ComObjectName & comObjNam, CollHeap * h=0); |
| |
| // copy ctor |
| QualifiedName (const QualifiedName & qual, NAMemory * h) : |
| SchemaName(qual, h), |
| objectName_(qual.objectName_, h), |
| objectNameSpace_(qual.objectNameSpace_), |
| flagbits_(qual.flagbits_) |
| {} |
| |
| // operators |
| QualifiedName & operator=(const QualifiedName &rhs); |
| inline NABoolean operator==(const QualifiedName&) const; |
| inline NABoolean operator!=(const QualifiedName&) const; |
| NABoolean operator==(const NAString&) const; |
| inline NABoolean operator!=(const NAString&) const; |
| |
| // accessors |
| ULng32 hash() const; |
| static ULng32 hash(const QualifiedName& name) { return name.hash(); } |
| |
| NAString getQualifiedNameAsString(NABoolean formatForDisplay = FALSE, |
| NABoolean externalDisplay = FALSE) const; |
| const NAString getQualifiedNameAsAnsiString(NABoolean formatForDisplay = FALSE, |
| NABoolean externalDisplay = FALSE) const; |
| const NAString getQualifiedNameAsAnsiString( |
| size_t *lenArray /* array[5] */) const; |
| const NAString getQualifiedNameAsAnsiNTFilenameString() const; |
| const NAString& getObjectName() const { return objectName_; } |
| const NAString getUnqualifiedObjectNameAsAnsiString() const |
| { return ToAnsiIdentifier(objectName_); } |
| |
| ComAnsiNameSpace getObjectNameSpace() const { return objectNameSpace_; } |
| |
| |
| NABoolean fullyExpanded() const { return catalogName_ != (const char *)""; } |
| |
| Int32 numberExpanded() const { |
| if(NOT catalogName_.isNull()) return 3; |
| if(NOT schemaName_.isNull()) return 2; |
| if(NOT objectName_.isNull()) return 1; |
| return 0; |
| } |
| |
| // Name parts return in string parameters, defaulted if not yet present; |
| // this object is not modified. |
| // Function return value is the number of names that match the default, |
| // {0, 1, 2} = {no matches, catalog matches, catalog&schema match}. |
| Int32 extractAndDefaultNameParts( const SchemaName& defCatSch |
| , NAString& catName |
| , NAString& schName |
| , NAString& objName |
| ) const; |
| |
| // Mutator to fill in default catalog & schema if not already present. |
| Int32 applyDefaults(const SchemaName& defCatSch); |
| |
| // apply defaults and validate the object existence |
| Int32 applyDefaultsValidate(const SchemaName& defCatSch, |
| ComAnsiNameSpace nameSpace = COM_TABLE_NAME); |
| |
| NABoolean applyShortAnsiDefault(NAString& catName, NAString& schName) const; |
| |
| NABoolean verifyAnsiNameQualification(Int32 nbrPartsDefaulted) const; |
| |
| static NABoolean isHive(const NAString &catName); |
| static NABoolean isHbase(const NAString &catName); |
| static NABoolean isSeabase(const NAString &catName); |
| |
| NABoolean isHive() const; |
| NABoolean isSeabase() const; |
| NABoolean isHbase() const; |
| NABoolean isSeabaseMD() const; |
| NABoolean isSeabasePrivMgrMD() const; |
| NABoolean isHbaseMappedName() const; |
| |
| NABoolean isHbaseCell() const; |
| NABoolean isHbaseRow() const; |
| NABoolean isHbaseCellOrRow() const; |
| |
| NABoolean isHistograms() const; |
| NABoolean isHistogramIntervals() const; |
| NABoolean isHistogramTable() const; |
| NABoolean isLOBDesc() const; |
| void setObjectName(const NAString &objName) { objectName_ = objName; } |
| void setObjectNameSpace(ComAnsiNameSpace objNameSpace) { objectNameSpace_ = objNameSpace; } |
| |
| NABoolean isVolatile() const { return (flagbits_ & IS_VOLATILE) != 0; } |
| void setIsVolatile(NABoolean v) |
| { (v ? flagbits_ |= IS_VOLATILE : flagbits_ &= ~IS_VOLATILE);} |
| |
| NABoolean isGhost() const { return (flagbits_ & IS_GHOST) != 0; } |
| void setIsGhost(NABoolean v) |
| { (v ? flagbits_ |= IS_GHOST : flagbits_ &= ~IS_GHOST);} |
| |
| |
| // Display/print, for debugging. |
| virtual void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "QualifiedName") const; |
| private: |
| enum FlagBits |
| { |
| IS_VOLATILE = 0x01, |
| IS_GHOST = 0x02 |
| }; |
| |
| NAString objectName_; |
| ComAnsiNameSpace objectNameSpace_; |
| |
| Int32 flagbits_; |
| |
| }; // QualifiedName |
| |
| // ----------------------------------------------------------------------- |
| // Partition Name, Number or Range. |
| // |
| // Holds the partition name, number, location name or |
| // a partition range specfied by the user in DML. |
| // These could be specified as part of 'special table name' clause and |
| // restrict DML actions to these partitions only. |
| // ----------------------------------------------------------------------- |
| class PartitionClause : public NABasicObject |
| { |
| |
| public: |
| |
| // constructors |
| PartitionClause(const NAString& pname,CollHeap * h=0) : |
| partName_(pname, h), |
| beginPartNumber_(-1), |
| endPartNumber_(-1), |
| locationName_("",h), |
| partnNameSpecified_(TRUE), |
| partnNumSpecified_(FALSE), |
| partnRangeSpecified_(FALSE) |
| {} |
| |
| PartitionClause(const Int32 pnum, CollHeap * h=0) : |
| partName_("", h), |
| beginPartNumber_(pnum), |
| endPartNumber_(-1), |
| locationName_("",h), |
| partnNameSpecified_(FALSE), |
| partnNumSpecified_(TRUE), |
| partnRangeSpecified_(FALSE) |
| {} |
| |
| PartitionClause(CollHeap * h=0) : |
| partName_("", h), |
| beginPartNumber_(-1), |
| endPartNumber_(-1), |
| locationName_("",h), |
| partnNameSpecified_(FALSE), |
| partnNumSpecified_(FALSE), |
| partnRangeSpecified_(FALSE) |
| {} |
| |
| PartitionClause(const Int32 beginPnum, const Int32 endPnum, |
| CollHeap * h=0) : |
| partName_("", h), |
| beginPartNumber_(beginPnum), |
| endPartNumber_(endPnum), |
| locationName_("",h), |
| partnNameSpecified_(FALSE), |
| partnNumSpecified_(FALSE), |
| partnRangeSpecified_(TRUE) |
| {} |
| |
| // copy ctor |
| PartitionClause (const PartitionClause& pClause , CollHeap * h=0) : |
| partName_(pClause.partName_, h), |
| beginPartNumber_(pClause.beginPartNumber_), |
| endPartNumber_(pClause.endPartNumber_), |
| locationName_(pClause.locationName_,h), |
| partnNameSpecified_(pClause.partnNameSpecified_), |
| partnNumSpecified_(pClause.partnNumSpecified_), |
| partnRangeSpecified_(pClause.partnRangeSpecified_) |
| {} |
| |
| // operators |
| NABoolean operator==(const PartitionClause&) const; |
| NABoolean operator!=(const PartitionClause&) const; |
| PartitionClause& operator= (const PartitionClause&) ; |
| ULng32 hash() const ; |
| NABoolean isEmpty() const; |
| |
| // accessors |
| const NAString& getPartitionName() const { return partName_; } |
| const Int32 getPartitionNumber() const { return beginPartNumber_; } |
| const Int32 getBeginPartitionNumber() const { return beginPartNumber_; } |
| const Int32 getEndPartitionNumber() const { return endPartNumber_; } |
| |
| const NAString& getLocationName() const { return locationName_; } |
| |
| const NABoolean partnNameSpecified() const { return partnNameSpecified_;} |
| const NABoolean partnNumSpecified() const { return partnNumSpecified_;} |
| const NABoolean partnRangeSpecified() const { return partnRangeSpecified_;} |
| |
| //mutator |
| void setLocationName(const NAString& locName) { locationName_ = locName; } |
| |
| private: |
| |
| NAString partName_; |
| Int32 beginPartNumber_; |
| Int32 endPartNumber_; |
| NAString locationName_; |
| |
| NABoolean partnNameSpecified_; |
| NABoolean partnNumSpecified_; |
| NABoolean partnRangeSpecified_; |
| }; // PartitionClause |
| |
| // ----------------------------------------------------------------------- |
| // Extended Qualified Name |
| // This class is introduced to abstract the Qualified ANSI name, |
| // special type and the Location Name, so that we can lookup NATableDB |
| // on the ExtendedQualName. |
| // ----------------------------------------------------------------------- |
| class ExtendedQualName : public NABasicObject |
| { |
| public: |
| enum SpecialTableType { NORMAL_TABLE, |
| INDEX_TABLE, |
| ISP_TABLE, // Internal Stored Procedure |
| LOAD_TABLE, |
| PARTITION_TABLE, |
| VIRTUAL_TABLE, |
| IUD_LOG_TABLE, |
| RANGE_LOG_TABLE, |
| HBMAP_TABLE, |
| MVS_UMD, |
| MV_TABLE, |
| TRIGTEMP_TABLE, // Temporary Tables for Triggers |
| SCHEMA_SECURITY_TABLE, |
| GHOST_TABLE, |
| GHOST_INDEX_TABLE, |
| GHOST_MV_TABLE, |
| GHOST_TRIGTEMP_TABLE, |
| EXCEPTION_TABLE, |
| GHOST_IUD_LOG_TABLE, |
| SG_TABLE, |
| LIBRARY_TABLE, |
| SCHEMA_TABLE |
| }; |
| |
| // constructors |
| ExtendedQualName(NAString objectName = "", |
| NAString schemaName = "", |
| NAString catalogName = "", |
| CollHeap * h=0, |
| NAString locName = "", |
| StringPos namePos = 0) : |
| qualName_(objectName, schemaName, catalogName, h, namePos), |
| type_(NORMAL_TABLE), |
| utilityOpenId_(-1), |
| isNSAOperation_(FALSE), |
| partnClause_(h) |
| { |
| setLocationName(locName); |
| } |
| |
| ExtendedQualName(const QualifiedName &qualName, |
| CollHeap * h=0, |
| NAString locName = (const char *)"") : |
| qualName_(qualName, h), |
| type_(NORMAL_TABLE), |
| utilityOpenId_(-1), |
| isNSAOperation_(FALSE), |
| partnClause_(h) |
| { |
| setLocationName(locName); |
| } |
| |
| ExtendedQualName(const ExtendedQualName & orig, CollHeap * h=0) : |
| qualName_(orig.qualName_, h), |
| type_(orig.type_), |
| utilityOpenId_(orig.utilityOpenId_), |
| isNSAOperation_(orig.isNSAOperation_), |
| partnClause_(orig.partnClause_,h) |
| {} |
| |
| // operators |
| NABoolean operator==(const ExtendedQualName&) const; |
| NABoolean operator!=(const ExtendedQualName&) const; |
| |
| // accessors |
| ULng32 hash() const; |
| NABoolean isEmpty() const; |
| NABoolean isLocationNameSpecified() const { return NOT getLocationName().isNull(); } |
| NABoolean isPartitionNameSpecified() const |
| { return (getPartnClause().partnNameSpecified() || |
| getPartnClause().partnNumSpecified()); } |
| NABoolean isPartitionRangeSpecified() const |
| { return (getPartnClause().partnRangeSpecified()); } |
| NABoolean isUtilityOpenIdSpecified() const {return (utilityOpenId_ != -1); } |
| NABoolean isNSAOperation() const {return isNSAOperation_; } |
| NABoolean isSpecialTable() const |
| { return (type_ != NORMAL_TABLE) |
| && (type_ != TRIGTEMP_TABLE) |
| && (type_ != EXCEPTION_TABLE) |
| && (type_ != IUD_LOG_TABLE) |
| && (type_ != RANGE_LOG_TABLE) |
| && (type_ != GHOST_TABLE) |
| && (type_ != GHOST_IUD_LOG_TABLE) |
| ; } |
| |
| NABoolean isGhost() const |
| { return (type_ == GHOST_TABLE) |
| || (type_ == GHOST_INDEX_TABLE) |
| || (type_ == GHOST_MV_TABLE) |
| || (type_ == GHOST_IUD_LOG_TABLE) |
| ; } |
| |
| //can this type of object be put in the NATable cache |
| NABoolean isCacheable() const |
| { |
| return (type_ == NORMAL_TABLE) |
| || (type_ == TRIGTEMP_TABLE) |
| || (type_ == EXCEPTION_TABLE) |
| //|| (type_ == IUD_LOG_TABLE) |
| //|| (type_ == RANGE_LOG_TABLE) |
| || (type_ == INDEX_TABLE) |
| || ((type_ == GHOST_TABLE)&& qualName_.isLOBDesc()) |
| ; } |
| |
| NABoolean hasPartnClause() const {return NOT partnClause_.isEmpty();} |
| |
| StringPos getNamePosition() const { return qualName_.getNamePosition();} |
| const NAString &getLocationName() const { return partnClause_.getLocationName(); } |
| Int64 getUtilityOpenId() const { return utilityOpenId_; } |
| const QualifiedName& getQualifiedNameObj() const { return qualName_; } |
| QualifiedName& getQualifiedNameObj() { return qualName_; } |
| SpecialTableType getSpecialType() const { return type_; } |
| static ComAnsiNameSpace convSpecialTableTypeToAnsiNameSpace( const SpecialTableType type ); // ++MV |
| ComAnsiNameSpace getAnsiNameSpace() const; // ++MV |
| const PartitionClause& getPartnClause() const {return partnClause_ ;} |
| NAString getExtendedQualifiedNameAsString() const; |
| |
| // Mutator to fill in qualified name from prototype value, if one. |
| void setLocationName(const NAString& locName) { partnClause_.setLocationName(locName); } |
| void setUtilityOpenId(Int64 &openId) { utilityOpenId_ = openId; } |
| void setIsNSAOperation(NABoolean isNSAOperation) |
| {isNSAOperation_ = isNSAOperation;} |
| void setNamePosition(StringPos pos, NABoolean setD = TRUE) |
| { qualName_.setNamePosition(pos, setD); } |
| void setSpecialType(SpecialTableType stt) { type_ = stt; } |
| void setPartnClause(const PartitionClause& pClause) {partnClause_ = pClause;} |
| |
| const NAString getSpecialTypeName() const; |
| |
| static NABoolean isDescribableTableType(SpecialTableType type) |
| { |
| return (type == NORMAL_TABLE || |
| type == INDEX_TABLE || |
| type == IUD_LOG_TABLE || |
| type == RANGE_LOG_TABLE || |
| type == MVS_UMD || |
| type == MV_TABLE || |
| type == TRIGTEMP_TABLE || |
| type == EXCEPTION_TABLE || |
| type == GHOST_TABLE || |
| type == GHOST_INDEX_TABLE || |
| type == GHOST_MV_TABLE || |
| type == GHOST_IUD_LOG_TABLE || |
| type == SG_TABLE |
| ); |
| } |
| |
| // Display/print, for debugging. |
| const NAString getText() const; |
| const NAString getTextWithSpecialType() const; |
| void display() const; |
| void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "ExtendedQualName") const; |
| |
| private: |
| |
| QualifiedName qualName_; // identity-discriminant |
| SpecialTableType type_; // identity-discriminant |
| |
| // The following two memebers are used by SQL/MX utility |
| // along with LOCATION clause. Think about factoring out |
| // the LOCATION clause info into a seperate class if this |
| // list gets larger. |
| |
| // Stores the 64-bit id that SQL/MX Utility passes |
| // in the LOCATION clause. |
| // Eg: LOCATION <locationName_> OPEN <utilityOpenId_>. Note that |
| // the OPEN clause is optional. |
| Int64 utilityOpenId_; |
| |
| // This member is set to TRUE, if the SQL/MX Utility |
| // specifies WITH SHARE ACCESS along with LOCATION clause. |
| // Eg. LOCATION <locationName_> WITH SHARE ACCESS. |
| NABoolean isNSAOperation_; |
| |
| // Holds the partition name/number specified by PARTITION clause of DML |
| PartitionClause partnClause_; // identity-discriminant |
| |
| }; //ExtendedQualName |
| |
| |
| // ----------------------------------------------------------------------- |
| // Correlation names |
| // |
| // A correlation name is used to identify a table. It consists of a |
| // qualified name ([ [ catalog . ] schema . ] table) and of a correlation |
| // (shortcut) name for the table. If no user-assigned correlation name |
| // is specified, then the entire table name becomes exposed, |
| // that is it becomes the implicit correlation name. |
| // See ANSI 6.3 and 6.4. |
| // |
| // CorrName also (optionally) contains information if this is a 'special' table. |
| // These are 'virtual' tables for special purpose needs. |
| // Binder uses this information to 'generate' table descriptors. |
| // Ustat does not fetch real histograms for virtual tables. |
| // ----------------------------------------------------------------------- |
| class CorrName : public NABasicObject |
| { |
| private: |
| enum FlagBits |
| { |
| OFF = 0, |
| ISFABRICATED = 0x1, |
| IS_VOLATILE = 0x2, |
| IS_EXTERNAL = 0x4 |
| }; |
| |
| public: |
| |
| // constructors |
| CorrName(const NAString & objectName = "", |
| CollHeap * h=0, |
| const NAString & schemaName = "", |
| const NAString & catalogName = "", |
| const NAString & corrName = "", |
| const NAString & locName = "", |
| StringPos namePos = 0, |
| HostVar *prototype = NULL) : |
| qualName_(objectName, schemaName, catalogName, h, namePos), |
| corrName_(corrName, h), |
| //ct-bug-10-030102-3803 -Begin |
| ugivenName_("", h), |
| //ct-bug-10-030102-3803 -End |
| prototype_(prototype), |
| bound_(FALSE), |
| defaultMatchCount_(-1), |
| flagbits_(0) |
| { |
| setIsExternal(ComIsTrafodionExternalSchemaName(schemaName)); |
| setLocationName (locName) ; |
| } |
| |
| CorrName(const QualifiedName & qualName, |
| CollHeap * h=0, |
| const NAString & corrName = "", |
| const NAString & locName = "", |
| HostVar *prototype = NULL) : |
| qualName_(qualName, h), |
| corrName_(corrName, h), |
| //ct-bug-10-030102-3803 -Begin |
| ugivenName_("", h), |
| //ct-bug-10-030102-3803 -End |
| prototype_(prototype), |
| bound_(FALSE), |
| defaultMatchCount_(-1), |
| flagbits_(0) |
| { |
| setIsExternal(ComIsTrafodionExternalSchemaName(qualName.getSchemaName())); |
| setLocationName (locName) ; |
| } |
| |
| // copy ctor |
| CorrName (const CorrName & corr, CollHeap * h=0) : |
| qualName_(corr.qualName_, h), |
| corrName_(corr.corrName_, h), |
| //ct-bug-10-030102-3803 -Begin |
| ugivenName_(corr.ugivenName_, h), |
| //ct-bug-10-030102-3803 -End |
| prototype_(corr.prototype_), |
| bound_(corr.bound_), |
| defaultMatchCount_(corr.defaultMatchCount_), |
| flagbits_(corr.flagbits_) |
| {} |
| |
| CorrName(const NAString& corrName, |
| NABoolean isFabricated, |
| CollHeap * h=0, |
| HostVar *prototype = NULL) : |
| qualName_("","", h), |
| corrName_(corrName, h), |
| //ct-bug-10-030102-3803 -Begin |
| ugivenName_("", h), |
| //ct-bug-10-030102-3803 -End |
| prototype_(prototype), |
| bound_(FALSE), |
| defaultMatchCount_(-1), |
| flagbits_(isFabricated ? ISFABRICATED : 0) |
| {} |
| |
| // assignment |
| CorrName& operator= (const CorrName&) ; |
| |
| // operators |
| NABoolean operator==(const CorrName&) const; |
| NABoolean operator!=(const CorrName&) const; |
| NABoolean operator==(const NAString&) const; |
| NABoolean operator!=(const NAString&) const; |
| |
| // accessors |
| StringPos getNamePosition() const { return qualName_.getNamePosition();} |
| HostVar *getPrototype() const { return prototype_; } |
| ULng32 hash() const; |
| NABoolean isEmpty() const; |
| NABoolean isFabricated() const { return flagbits_ & ISFABRICATED; } |
| |
| NABoolean isVolatile() const { return (qualName_.getQualifiedNameObj().isVolatile()); } |
| void setIsVolatile(NABoolean v) { qualName_.getQualifiedNameObj().setIsVolatile(v); } |
| |
| NABoolean nodeIsBound() const { return bound_; } |
| void markAsBound() { bound_ = TRUE; } |
| |
| NABoolean isSpecialTable() const { return qualName_.isSpecialTable(); } |
| NABoolean isCacheable() const { return qualName_.isCacheable(); } |
| ExtendedQualName::SpecialTableType getSpecialType() const |
| { return qualName_.getSpecialType(); } |
| ComAnsiNameSpace getAnsiNameSpace() const |
| { return qualName_.getAnsiNameSpace(); } |
| void setSpecialType(ExtendedQualName::SpecialTableType stt) |
| { qualName_.setSpecialType (stt); } |
| void setSpecialType(const CorrName &cn) |
| { qualName_.setSpecialType (cn.getSpecialType()); } |
| |
| const ExtendedQualName& getExtendedQualNameObj() const { return qualName_; } |
| |
| // unconditional returns (in particular, regardless of isFabricated!) |
| const QualifiedName& getQualifiedNameObj() const |
| {return qualName_.getQualifiedNameObj();} |
| QualifiedName& getQualifiedNameObj() {return qualName_.getQualifiedNameObj();} |
| NAString getCorrNameAsString() const; |
| |
| // build strings to be returned, based on condition |
| NAString getQualifiedNameAsString(NABoolean formatForDisplay = FALSE) const; |
| const NAString getExposedNameAsString(NABoolean debug = FALSE, |
| NABoolean formatForDisplay = FALSE) const; |
| const NAString getExposedNameAsAnsiString(NABoolean debug = FALSE, |
| NABoolean formatForDisplay = FALSE) const; |
| const NAString getExposedNameAsStringWithPartitionNames() const; |
| |
| const NAString &getLocationName() const { return qualName_.getLocationName();} |
| NABoolean isLocationNameSpecified() const |
| { return qualName_.isLocationNameSpecified(); } |
| NABoolean isPartitionNameSpecified() const |
| { return qualName_.isPartitionNameSpecified(); } |
| NABoolean isPartitionRangeSpecified() const |
| { return qualName_.isPartitionRangeSpecified(); } |
| //ct-bug-10-030102-3803 -Begin |
| const NAString getUgivenName() const { return ugivenName_; } |
| //ct-bug-10-030102-3803 -End |
| |
| Int64 getUtilityOpenId() const { return qualName_.getUtilityOpenId(); } |
| NABoolean isUtilityOpenIdSpecified() const |
| {return qualName_.isUtilityOpenIdSpecified(); } |
| NABoolean isNSAOperation() |
| const {return qualName_.isNSAOperation(); } |
| |
| const PartitionClause& getPartnClause () const {return qualName_.getPartnClause();} |
| NABoolean hasPartnClause () const {return qualName_.hasPartnClause();} |
| NABoolean isEqualWithPartnClauseSkipped(const CorrName&) const ; |
| |
| // mutators |
| |
| // See QualifiedName::extractAndDefaultNameParts. |
| // In addition, if this CorrName contains a correlation name |
| // (masking a qualified name), the function return is always 0 |
| // and the name parts are *not* filled in (they're meaningless). |
| Int32 extractAndDefaultNameParts(BindWA *bindWA, |
| const SchemaName& defCatSch, |
| NAString& catName, |
| NAString& schName, |
| NAString& objName); |
| |
| // Mutator to fill in default catalog & schema if not already present. |
| // Does *NOT* look at this CorrName's corr name |
| // (unlike CorrName::extractAndDefaultNameParts above). |
| Int32 applyDefaults(BindWA *bindWA, const SchemaName& defCatSch); |
| |
| // Mutator to fill in qualified name from prototype value, if one. |
| void applyPrototype(BindWA *bindWA); |
| |
| // Only Parser should call this ('table_reference: table_name as_clause')! |
| void setCorrName(const NAString& corrName); |
| //ct-bug-10-030102-3803 -Begin |
| void setUgivenName(const NAString& corrName); |
| //ct-bug-10-030102-3803 -End |
| void setLocationName(const NAString& loc) { qualName_.setLocationName(loc); } |
| void setUtilityOpenId(Int64 &openId) { qualName_.setUtilityOpenId(openId); } |
| void setNamePosition(StringPos pos, NABoolean setD = TRUE) |
| { qualName_.setNamePosition(pos, setD); } |
| |
| void setIsNSAOperation(NABoolean isNSAOperation) |
| {qualName_.setIsNSAOperation(isNSAOperation);} |
| |
| void setPrototype(HostVar *hv) { prototype_ = hv; } |
| // hv->setPrototypeTarget(this); |
| void setPartnClause(const PartitionClause& pClause) |
| { qualName_.setPartnClause(pClause); } |
| |
| NABoolean isATriggerTransitionName(BindWA *bindWA, NABoolean onlyNew=FALSE) const; |
| |
| NABoolean isHive() const; |
| NABoolean isInHiveDefaultSchema() const; |
| NABoolean isSeabase() const; |
| NABoolean isHbase() const; |
| NABoolean isSeabaseMD() const; |
| NABoolean isSeabasePrivMgrMD() const; |
| NABoolean isHbaseCell() const; |
| NABoolean isHbaseRow() const; |
| NABoolean isHbaseMap() const; |
| |
| |
| NABoolean isExternal() const { return (flagbits_ & IS_EXTERNAL) != 0; } |
| void setIsExternal(NABoolean v) |
| { (v ? flagbits_ |= IS_EXTERNAL : flagbits_ &= ~IS_EXTERNAL); } |
| |
| // Display/print, for debugging. |
| const NAString getTextWithSpecialType() const |
| { return qualName_.getTextWithSpecialType(); } |
| |
| const NAString getText() const; // see RelExpr.C |
| void display() const; |
| void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "CorrName") const; |
| // To quote reserved words in define value. The caller is expected to provide sufficent |
| // space in the INOUT parameter, defineValue should be at least 40 characters in length |
| static unsigned char *quoteDefineValue(unsigned char *defineValue); |
| private: |
| |
| ExtendedQualName qualName_; // identity-discriminant |
| NAString corrName_; // identity-discriminant |
| //ct-bug-10-030102-3803 -Begin |
| NAString ugivenName_; |
| //ct-bug-10-030102-3803 -End |
| NABoolean bound_; |
| Int32 flagbits_; // identity-discriminant |
| HostVar *prototype_; |
| Int32 defaultMatchCount_; |
| |
| // Before adding new members to this class, think about whether it is |
| // an identity-discriminating field and so should be compared against |
| // in CorrName::operator==, and be sure to read the notes in that method's |
| // implementation about what other changes will be necessary. |
| |
| }; // CorrName |
| |
| // ----------------------------------------------------------------------- |
| // Column reference names |
| // |
| // A column reference may be |
| // qualified (table.col) or unqualified (col) or a star (table.* or *). |
| // ----------------------------------------------------------------------- |
| class ColRefName : public NABasicObject |
| { |
| |
| public: |
| |
| // constructors |
| |
| ColRefName(CollHeap * h=0) : |
| colName_("", h), |
| corrName_("", h), |
| isStar_(NO_STAR) |
| {} |
| |
| // Only Parser uses the first two ctors, which set the isStar flag. |
| // Parser and Binder both use the others. |
| ColRefName(Int32 forceStar, CollHeap * h=0) : |
| colName_("", h), |
| corrName_("", h), |
| isStar_(IS_STAR) |
| { CMPASSERT(forceStar == TRUE); } |
| |
| ColRefName(Int32 forceStar, const CorrName& corr, CollHeap * h=0) : |
| colName_("", h), |
| corrName_(corr, h), |
| isStar_(IS_STAR) |
| { CMPASSERT(forceStar == TRUE); } |
| |
| ColRefName(const NAString& col, CollHeap * h=0) : |
| colName_(col, h), |
| corrName_("", h), |
| isStar_(NO_STAR) |
| {} |
| |
| ColRefName(const NAString& col, const CorrName& corr, CollHeap * h=0) : |
| colName_(col, h), |
| corrName_(corr, h), |
| isStar_(NO_STAR) |
| {} |
| |
| // copy ctor |
| ColRefName (const ColRefName & colref, CollHeap * h=0) : |
| colName_(colref.colName_, h), |
| corrName_(colref.corrName_, h), |
| isStar_(colref.isStar_) |
| {} |
| |
| // operators |
| NABoolean operator==(const ColRefName&) const; |
| NABoolean operator!=(const ColRefName&) const; |
| |
| // accessors |
| StringPos getNamePosition() const { return corrName_.getNamePosition();} |
| ULng32 hash() const; |
| NABoolean isEmpty() const; |
| NABoolean isFabricated() const { return corrName_.isFabricated(); } |
| |
| // return True if reference is a literal *, not a delimited name "*" |
| // (only the Parser should be setting this flag) |
| NABoolean isStar() const { return isStar_!=NO_STAR; } |
| NABoolean getStarWithSystemAddedCols() const |
| { return isStar_==STAR_WITH_SYSTEM_ADDED_COLS; } |
| |
| // return the correlation name and simple column name |
| const CorrName& getCorrNameObj() const { return corrName_; } |
| CorrName& getCorrNameObj() { return corrName_; } |
| const NAString& getColName() const { return colName_; } |
| const NAString getColNameAsAnsiString() const; |
| |
| // return "col", "corr.col", or "cat.sch.tbl.col", whichever is appropriate |
| const NAString getColRefAsAnsiString(NABoolean debug = FALSE, |
| NABoolean formatForDisplay = FALSE) const; |
| const NAString getColRefAsString(NABoolean debug = FALSE, |
| NABoolean formatForDisplay = FALSE) const; |
| static |
| const NAString getColRefAsString(const NAString& col, |
| const NAString& corr) |
| { |
| if (corr == (const char *)"") return col; |
| else |
| { |
| NAString returnVal(corr.length() +1 + col.length()); |
| returnVal.append(corr); |
| returnVal.append("."); |
| returnVal.append(col); |
| return returnVal; |
| } |
| } |
| |
| NABoolean isDelimited() const |
| { return corrName_.getQualifiedNameObj().isDelimited(); } |
| |
| // mutators |
| void setSpecialType(ExtendedQualName::SpecialTableType stt) |
| { corrName_.setSpecialType(stt); } |
| void setNamePosition(StringPos pos, NABoolean setD = TRUE) |
| { corrName_.setNamePosition(pos, setD); } |
| void setStarWithSystemAddedCols() { isStar_ = STAR_WITH_SYSTEM_ADDED_COLS; } |
| void setPartnClause(PartitionClause pClause) { corrName_.setPartnClause(pClause); } |
| |
| // Display/print, for debugging. |
| void display() const; |
| void print(FILE* ofd = stdout, |
| const char* indent = DEFAULT_INDENT, |
| const char* title = "ColRefName", |
| NABoolean brief = FALSE) const; |
| |
| NABoolean isQualified() const; |
| |
| private: |
| enum starType { NO_STAR = FALSE, IS_STAR = TRUE, STAR_WITH_SYSTEM_ADDED_COLS }; |
| |
| CorrName corrName_; |
| NAString colName_; |
| starType isStar_; |
| |
| }; // ColRefName |
| |
| |
| // ----------------------------------------------------------------------- |
| // -- Triggers |
| // The TableRefName class is used to pass the REFERENCING clause of |
| // trigger declarations from the parser to the binder. |
| // Each object holds a table name (or correlation name to a table) and |
| // a referencing name. For example, if the trigger contains the text: |
| // "REFERENCING NEW AS MY_NEW", the referencing name is "MY_NEW", and |
| // the table name is "NEW@" (or whatever NEWCorr turnes out to be). |
| // ----------------------------------------------------------------------- |
| class TableRefName : public NABasicObject |
| { |
| |
| public: |
| |
| // constructors |
| TableRefName(CollHeap *h = CmpCommon::statementHeap()) : |
| tableName_("",h), refName_("",h), tableCorr_("",h), columnList_(NULL) |
| {} |
| |
| TableRefName(const NAString& tableName, const NAString& refName, |
| CollHeap *h = CmpCommon::statementHeap()) : |
| tableName_(tableName, h), refName_(refName, h), tableCorr_(tableName_, h), |
| columnList_(NULL) |
| {} |
| |
| TableRefName(const TableRefName& other, CollHeap *h = CmpCommon::statementHeap()) : |
| tableName_(other.tableName_, h), refName_(other.refName_, h), |
| tableCorr_(other.tableCorr_, h), columnList_(other.columnList_) |
| {} |
| |
| // operators |
| NABoolean operator==(const TableRefName& other) const |
| { return ((getTableName() == other.getTableName()) && |
| (getRefName() == other.getRefName())); } |
| |
| NABoolean operator!=(const TableRefName& other) const |
| { return !(*this == other); } |
| |
| TableRefName &operator=(const TableRefName& rhs) |
| { |
| // TableRefName *newMe = new(CmpCommon::statementHeap()) TableRefName(rhs); |
| // this = newMe; |
| tableName_ = rhs.tableName_; |
| refName_ = rhs.refName_; |
| tableCorr_ = rhs.tableCorr_; |
| columnList_ = rhs.columnList_; |
| return *this; |
| } |
| |
| // accessors |
| inline const NAString& getTableName() const { return tableName_; } |
| inline const NAString& getRefName() const { return refName_; } |
| inline const CorrName& getTableCorr() const { return tableCorr_; } |
| inline const ColumnDescList *getColumnList() const { return columnList_; } |
| inline void setColumnList(ColumnDescList *columnList) |
| { columnList_ = columnList; } |
| |
| Int32 lookupTableName(RETDesc *retDesc); |
| void bindRefColumns(BindWA *bindWA) const; |
| |
| private: |
| |
| NAString tableName_; |
| NAString refName_; |
| CorrName tableCorr_; |
| ColumnDescList *columnList_; |
| }; // TableRefName |
| |
| class TableRefList : public LIST(TableRefName) |
| { |
| public: |
| TableRefList(CollHeap *heap = CmpCommon::statementHeap()); |
| |
| const TableRefName *findTable(const CorrName& tableCorr) const; |
| }; // TableRefList |
| |
| // ----------------------------------------------------------------------- |
| // MV |
| // This class contains the neccessary details of an MV that is using |
| // a table. The NATable of a base table contains a list of these |
| // objects, with the details of all the MVs that are using this table. |
| // This information is used for logging and immediate refresh operations. |
| // ----------------------------------------------------------------------- |
| class UsingMvInfo : public NABasicObject |
| { |
| public: |
| UsingMvInfo( NAString mvAnsiName, |
| ComMVRefreshType refreshType, |
| NABoolean isRewriteEnabled, |
| NABoolean isInitialized, |
| CollHeap *heap) |
| : mvName_(mvAnsiName, 3, heap), |
| refreshType_(refreshType), |
| isRewriteEnabled_(isRewriteEnabled), |
| isInitialized_(isInitialized) |
| {} |
| |
| const QualifiedName& getMvName() const { return mvName_; } |
| ComMVRefreshType getRefreshType() const { return refreshType_; } |
| NABoolean isRewriteEnabled() const { return isRewriteEnabled_; } |
| NABoolean isInitialized() const { return isInitialized_; } |
| |
| private: |
| const QualifiedName mvName_; |
| const ComMVRefreshType refreshType_; // unknown here means "non incremental" |
| const NABoolean isRewriteEnabled_; |
| const NABoolean isInitialized_; |
| }; |
| |
| typedef LIST(UsingMvInfo *) UsingMvInfoList; |
| |
| // ----------------------------------------------------------------------- |
| // Inline methods for class QualifiedName |
| // ----------------------------------------------------------------------- |
| |
| inline |
| NABoolean QualifiedName::operator==(const QualifiedName& other) const |
| { |
| return |
| getObjectName() == other.getObjectName() && |
| getSchemaName() == other.getSchemaName() && |
| getCatalogName() == other.getCatalogName() && |
| ( getObjectNameSpace() == other.getObjectNameSpace() || |
| getObjectNameSpace() == COM_UNKNOWN_NAME || // keep pre-R2.5 behavior |
| COM_UNKNOWN_NAME == other.getObjectNameSpace() ); // keep pre-R2.5 behavior |
| } |
| |
| inline |
| NABoolean QualifiedName::operator!=(const QualifiedName& other) const |
| { |
| return NOT operator==(other); |
| } |
| |
| inline |
| NABoolean QualifiedName::operator!=(const NAString& simpleName) const |
| { |
| return NOT operator==(simpleName); |
| } |
| |
| inline |
| ULng32 QualifiedName::hash() const |
| { |
| return getObjectName().hash() ^ |
| getSchemaName().hash() ^ |
| getCatalogName().hash(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Inline methods for class ExtendedQualName |
| // ----------------------------------------------------------------------- |
| |
| inline |
| NABoolean ExtendedQualName::operator!=(const ExtendedQualName& other) const |
| { |
| return NOT operator==(other); |
| } |
| |
| inline |
| ULng32 ExtendedQualName::hash() const |
| { |
| return getQualifiedNameObj().hash()^ |
| getPartnClause().hash(); |
| } |
| |
| inline |
| NABoolean ExtendedQualName::isEmpty() const |
| { |
| ExtendedQualName empty; |
| return *this == empty; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Inline methods for class CorrName |
| // ----------------------------------------------------------------------- |
| |
| inline |
| NABoolean CorrName::operator!=(const CorrName& other) const |
| { |
| return NOT operator==(other); |
| } |
| |
| // Comparison operators just for coding simplicity in callers |
| // ( Remove the cutesy == and != operators overloaded for NAString& ? ) |
| inline |
| NABoolean CorrName::isEmpty() const |
| { |
| // beware of stack variable declarations like this "CorrName empty;" |
| // their implicit constructor & destructor calls can slow us down. |
| static const CorrName empty; |
| return *this == empty; |
| } |
| |
| inline |
| NABoolean CorrName::operator==(const NAString& other) const |
| { |
| CMPASSERT(other == (const char *)""); |
| return isEmpty(); |
| } |
| |
| inline |
| NABoolean CorrName::operator!=(const NAString& other) const |
| { |
| return NOT operator==(other); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Inline methods for class ColRefName |
| // ----------------------------------------------------------------------- |
| inline |
| NABoolean ColRefName::isEmpty() const |
| { |
| return getColName() == (const char *)""; |
| } |
| |
| inline |
| ULng32 ColRefName::hash() const |
| { |
| return getCorrNameObj().hash() ^ |
| getColName().hash(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Inline methods for class PartitionClause |
| // ----------------------------------------------------------------------- |
| |
| inline |
| NABoolean PartitionClause::operator==(const PartitionClause& other) const |
| { |
| return (getPartitionName() == other.getPartitionName() && |
| getBeginPartitionNumber() == other.getBeginPartitionNumber() && |
| getEndPartitionNumber() == other.getEndPartitionNumber() && |
| getLocationName() == other.getLocationName()); |
| } |
| |
| inline |
| NABoolean PartitionClause::operator!=(const PartitionClause& other) const |
| { |
| return NOT operator==(other); |
| } |
| |
| inline |
| ULng32 PartitionClause::hash() const |
| { |
| ULng32 hashVal = |
| getPartitionName().hash() ^ |
| getBeginPartitionNumber() ^ |
| getLocationName().hash(); |
| |
| if (getEndPartitionNumber() > 0) |
| hashVal ^= getEndPartitionNumber(); |
| |
| return hashVal; |
| } |
| |
| inline |
| NABoolean PartitionClause::isEmpty() const |
| { |
| // beware of stack variable declarations like this "PartitionClause empty;" |
| // their implicit constructor & destructor calls can slow us down. |
| static const PartitionClause empty; |
| return *this == empty; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // External declarations |
| // ----------------------------------------------------------------------- |
| |
| // For NAKeyLookup |
| ULng32 hashKey(const QualifiedName&); |
| ULng32 hashKey(const ExtendedQualName&); |
| ULng32 hashKey(const CorrName&); |
| ULng32 hashKey(const ColRefName&); |
| |
| // ----------------------------------------------------------------------- |
| // ObjectCounter class |
| // ----------------------------------------------------------------------- |
| |
| class ObjectCounter |
| { |
| public: |
| ObjectCounter(Lng32 startPoint=0) |
| { |
| count_ = waterMark_ = totalAllocations_ = startPoint; |
| }; |
| inline Lng32 counter() {return count_;}; |
| inline Lng32 waterMark() {return waterMark_;}; |
| inline Lng32 totalAllocations() {return totalAllocations_;}; |
| inline void incrementCounter() |
| { |
| #ifdef OPT_ANALYSIS |
| ++ count_; |
| if (count_>waterMark_) |
| waterMark_ = count_; |
| ++ totalAllocations_; |
| #endif /* OPT_ANALYSIS */ |
| }; |
| inline void decrementCounter() |
| { |
| #ifdef OPT_ANALYSIS |
| -- count_; |
| #endif /* OPT_ANALYSIS */ |
| }; |
| inline void initializeCounter() { count_ = waterMark_ = 0;}; |
| |
| private: |
| Lng32 count_; |
| Lng32 waterMark_; |
| Lng32 totalAllocations_; |
| }; |
| |
| |
| //------------------------------------------------------------ |
| // a counter class that keeps track of counts of time tasks |
| // been executed and time elapsed in execution |
| //------------------------------------------------------------ |
| |
| class TaskMonitor |
| { |
| public: |
| TaskMonitor() : count_(0), goodCounts_(0), timer_(0), et_(0.0) |
| { |
| } |
| |
| // This function was added to reset counters to initial values, |
| // usually zeros, to allow monitor statistics being collected |
| // and printed several times inside the loop. |
| inline void init(Lng32 initval) |
| { |
| count_ = goodCounts_ = initval; |
| timer_ = (clock_t)initval; |
| et_ = 0.0; |
| } |
| inline void enter() |
| { |
| currTime_ = clock(); |
| count_++; |
| |
| struct timeval x; |
| gettimeofday(&x, NULL); |
| |
| et_ = double(x.tv_sec) + double(x.tv_usec) / 1000000; |
| } |
| |
| inline void exit() |
| { |
| currTime_ = clock() - currTime_; |
| |
| struct timeval x; |
| gettimeofday(&x, NULL); |
| |
| double new_et = double(x.tv_sec) + double(x.tv_usec) / 1000000; |
| et_ = new_et - et_; |
| |
| timer_ += currTime_; |
| if (currTime_) goodCounts_++; |
| } |
| inline Lng32 count() { return count_;} |
| inline Lng32 goodcount() { return goodCounts_;} |
| inline clock_t timer() { return timer_;} |
| |
| // return the elapsed time in seconds |
| float elapsed_time() { return et_; } |
| |
| private: |
| Lng32 count_; |
| Lng32 goodCounts_; // counts of tasks that took more than 1 ms |
| // to execute (not accurate). |
| clock_t timer_; |
| clock_t currTime_; |
| |
| double et_; |
| }; |
| |
| |
| ostream& operator<< (ostream&, TaskMonitor); |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| #endif /* OBJECTNAMES_H */ |
