| /********************************************************************** |
| // @@@ 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 NASTRING_H |
| #define NASTRING_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: NAString.h |
| * Description: common definitions of basic data types |
| * |
| * Created: 4/27/94 |
| * Language: C++ |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| #include "BaseTypes.h" |
| #include "Int64.h" |
| #include "CollHeap.h" |
| #include "ComCharSetDefs.h" |
| #include "NAStringDef.h" |
| #include "NAWinNT.h" |
| |
| // ----------------------------------------------------------------------- |
| // a string datatype |
| // ----------------------------------------------------------------------- |
| |
| // NB: NAString no longer IS RWCString ; instead, it's a separate class, |
| // derived from RWCString, with all allocation changed from global new to |
| // instead use a CollHeap * |
| |
| //#define NASTRING RWCString // needed by c89 compiler in a few places |
| |
| // the class NAString methods are contained in NAStringDef.h/NAStringDef.cpp |
| |
| // The following methods have to be defined for a NAString: |
| // |
| // - a default constructor (no length restrictions for the created string) |
| // - type conversion from and to char * |
| // - copy constructor |
| // - indexing operator char & operator[] (StringPos) |
| // - a substring operator NoahString operator() (StringPos start,StringPos len) |
| // - assignment operator (see below) |
| // - length operator StringPos length() |
| // - other methods as needed (use Tools.h++ method names) |
| // |
| // We expect the NAString data type to be implemented such that it "owns" |
| // the character string contained in it. That means that when a value is |
| // assigned to a NAString, then a copy is made of the source string such |
| // that the user of NAString is not required to keep the source of the |
| // assignment around. The copy of the string may be deleted at the next |
| // assignment, with the destructor, or in any other consistent way. See |
| // the Tools.h++ implementation of RWCString for an example on how this |
| // could work. |
| |
| // We require a behavior like an array index from the StringPos data |
| // type. A type conversion (if necessary) must be defined such that integers |
| // from 0 upwards can be used to address string elements (astring[0] must |
| // access the first element). |
| |
| // ----------------------------------------------------------------------- |
| // Methods on strings (defined as standalone C procedures, since we have |
| // no control over the RWCString class. |
| // |
| // Note that convertNAString() allocates memory. |
| // ----------------------------------------------------------------------- |
| |
| char* convertNAString(const NAString &ns, CollHeap *heap, |
| NABoolean wideNull = FALSE); |
| void GetSimplePosixFilename(NAString &filename, NABoolean doLower = FALSE); |
| ULng32 hashKey(const NAString &ns); |
| NABoolean IsNAStringSpace(const NAString &ns); |
| NABoolean IsNAStringSpaceOrEmpty(const NAString &ns); |
| NABoolean NAStringHasOnly7BitAsciiChars(const NAString& ns); |
| NABoolean NAStringHasOnlyDecimalDigitAsciiChars(const NAString& ns); |
| NABoolean IsSqlReservedWord(const char *sqlText); |
| NABoolean IsCIdentifier(const char *id); |
| NAString LookupDefineName(const NAString &ns, NABoolean iterate = FALSE); |
| void NAStringUpshiftASCII(NAString &ns); |
| Lng32 NAStringToLong(const NAString &ns); |
| double NAStringToReal(const NAString &ns); |
| UInt32 NAStringToUnsigned(const NAString &ns); |
| NAString LongToNAString(Lng32 l); |
| NAString RealToNAString(double d); |
| NAString UnsignedToNAString(UInt32 u); |
| NAString Int64ToNAString(Int64 l); |
| |
| // ----------------------------------------------------------------------- |
| // ANSI SQL name related functions |
| // ----------------------------------------------------------------------- |
| |
| NAString ToAnsiIdentifier(const NAString &ns, NABoolean assertShort=TRUE); |
| char * ToAnsiIdentifier2(const char * nsData, size_t nsLen, |
| CollHeap * heap); |
| char * ToAnsiIdentifier2(const char * nsData, size_t nsLen, |
| CollHeap * heap, Lng32 isoMapCS); |
| void ToAnsiIdentifier3(const char * inputData, size_t inputLen, |
| char * outputData, size_t outputMaxLen, size_t * outputLen); |
| void ToAnsiIdentifier3(const char * inputData, size_t inputLen, |
| char * outputData, size_t outputMaxLen, size_t * outputLen, |
| Lng32 isoMapCS); |
| |
| // The following macro definitions are for the flags parameter of ToInternalIdentifier() |
| #define NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT 0x0001 |
| #define NASTRING_REGULAR_IDENT_WITH_DOLLAR_PREFIX 0x0002 |
| #define NASTRING_DELIM_IDENT_WITH_DOLLAR_PREFIX 0x0004 |
| Lng32 ToInternalIdentifier( NAString &ansiIdent |
| , Int32 upCase = TRUE |
| , NABoolean acceptCircumflex = FALSE |
| , UInt16 pv_flags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT |
| ); |
| |
| // ----------------------------------------------------------------------- |
| // SQL text related functions |
| // ----------------------------------------------------------------------- |
| |
| void ToInternalString(NAString &internalStr, const NAString "edStr); |
| void ToQuotedString( NAString "edStr |
| , const NAString &internalStr |
| , NABoolean encloseInQuotes = TRUE); |
| Lng32 PrettifySqlText(NAString &sqlText, |
| const char *nationalCharSetName = NULL); |
| size_t LineBreakSqlText(NAString &sqlText, |
| NABoolean showddlView = FALSE, |
| size_t maxlen = 79, |
| size_t pfxlen = 2,// indent subsequent lines 2 spaces |
| size_t pfxinitlen = 0,// indent first line 0 spaces |
| char pfxchar = ' ', |
| const char *schemaName = NULL, |
| NABoolean commentOut = FALSE); |
| |
| void TrimNAStringSpace(NAString &ns, NABoolean leading = TRUE, |
| NABoolean trailing = TRUE); |
| size_t IndexOfFirstWhiteSpace(const NAString &ns, size_t startPos = 0); |
| size_t IndexOfFirstNonWhiteSpace(const NAString &ns, size_t startPos = 0); |
| |
| void RemoveLeadingZeros(NAString &ns); |
| void RemoveTrailingZeros(NAString &ns); |
| |
| NAString Latin1StrToUTF8(const NAString & latin1Str, NAMemory * heap = NULL); |
| |
| NAString &replaceAll(NAString &source, const NAString &searchFor, |
| const NAString &replaceWith); |
| |
| |
| // See notes at NAString.cpp specialSQL_TEXT[]. |
| // |
| // Also note that use of this non-Ansi value is going to break when we start |
| // supporting character sets beyond SQL_TEXT; then we will either have to have |
| // a function that returns an out-of-charset character for each given charset, |
| // and concatenate our internal unconflicting object names on the fly, |
| // rather than this nice simple hardcoded approach, OR |
| // change this '@' to '\001' or some such impossible-in-all-charsets character |
| // (as it's a nonprinting ascii char, using it will make debugging a tiny bit |
| // less obvious, that's all). |
| // |
| #define NON_SQL_TEXT_CHAR '@' |
| #define NON_SQL_TEXT_STR "@" |
| #define FUNNY_INTERNAL_IDENT(str) str NON_SQL_TEXT_STR |
| #define FUNNY_ANSI_IDENT(str) "\"" str NON_SQL_TEXT_STR "\"" |
| #define FUNNY_ANSI_IDENT_HAS_PREFIX(str,pfx) \ |
| (strncmp(str, "\"" pfx, strlen("\"" pfx)) == 0) |
| |
| void FUNNY_ANSI_IDENT_REMOVE_PREFIX(NAString &str, const char *pfx); |
| |
| // Syntactic sugar to call Space::allocateAndCopyToAlignedSpace() in exp_space.C |
| // (because exe/exp cannot use NAString/RWCString stuff, since exe/exp |
| // is in a system library...) |
| #define AllocateAndCopyToAlignedSpace(/* const NAString& */ ns, \ |
| /* size_t */ countPrefixSize) \ |
| allocateAndCopyToAlignedSpace( \ |
| (ns).data(), (ns).length(), countPrefixSize) |
| |
| // ----------------------------------------------------------------------- |
| // Routines to set and access the NAString_isoMappingCS memory cache for |
| // use by routines ToInternalIdentifier() and ToAnsiIdentifier[2|3]() in |
| // modules w:/common/NAString[2].cpp. These routines currently cannot |
| // access SqlParser_ISO_MAPPING directly due to the complex build hierarchy. |
| // ----------------------------------------------------------------------- |
| Lng32 NAString_getIsoMapCS(); |
| void NAString_setIsoMapCS(Lng32 isoMappingCS); |
| |
| // ----------------------------------------------------------------------- |
| // Routines use by routines ToInternalIdentifier() and |
| // ToAnsiIdentifier[2|3]() in modules w:/common/NAString[2].cpp. |
| // ----------------------------------------------------------------------- |
| inline SQLCHARSET_CODE ComGetNameInterfaceCharSet() |
| { |
| return SQLCHARSETCODE_UTF8; |
| } |
| |
| inline void ComSetNameInterfaceCharSet(SQLCHARSET_CODE ansiNameCharSet) |
| { |
| // ComASSERT(ansiNameCharSet == SQLCHARSETCODE_UTF8); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // if NAString_getIsoMapCS() == (Lng32)SQLCHARSETCODE_ISO88591 |
| // call the corresponding ...8859_1() routine |
| // otherwise only execute the corresponding 7-bit ASCII logic |
| NABoolean isUpperIsoMapCS(unsigned char c); |
| NABoolean isAlphaIsoMapCS(unsigned char c); |
| NABoolean isAlNumIsoMapCS(unsigned char c); |
| void NAStringUpshiftIsoMapCS(NAString &ns); |
| |
| #endif /* NASTRING_H */ |
| |
| // ----------------------------------------------------------------------- |
| // This is necessary if you want to make a NAKeyLookup (hash table) |
| // containing elements that are NAString only. |
| // ----------------------------------------------------------------------- |
| #ifdef USING_NAKEYLOOKUPONNASTRINGONLY |
| #ifndef NAKEYLOOKUPONNASTRINGONLY_H |
| #define NAKEYLOOKUPONNASTRINGONLY_H |
| |
| #include "Collections.h" |
| |
| class NAStringAsOnlyValueInNAKeyLookup : public NAString |
| { |
| public: |
| NAStringAsOnlyValueInNAKeyLookup() : NAString() {} |
| NAStringAsOnlyValueInNAKeyLookup(const char *str) : NAString(str) {} |
| NAStringAsOnlyValueInNAKeyLookup(const NAString &str) : NAString(str) {} |
| |
| const NAString *getKey() const { return this; } |
| // inherits NAString::operator==() |
| // likewise hashkey(const NAString&) will be used by NAKeyLookup |
| }; |
| |
| class NAKeyLookupOnNAStringOnly : public NAKeyLookup< |
| NAString,NAStringAsOnlyValueInNAKeyLookup> |
| { |
| public: |
| NAKeyLookupOnNAStringOnly(short initSize = 29, CollHeap* h = NULL) : |
| NAKeyLookup<NAString,NAStringAsOnlyValueInNAKeyLookup> |
| (initSize, NAKeyLookupEnums::KEY_INSIDE_VALUE, h) {} |
| |
| //copy ctor |
| NAKeyLookupOnNAStringOnly (const NAKeyLookupOnNAStringOnly & orig, CollHeap * h=0) ; |
| |
| ~NAKeyLookupOnNAStringOnly() |
| { |
| //## This is commented out because it causes the dtor to crash. |
| //## The only current user of this class wants this hashtable to |
| //## persist over the entire lifetime of arkcmp, so memory leakage |
| //## is not an issue for it. But other (future) users, beware! |
| //## |
| //## clearAndDestroy(); |
| } |
| }; |
| |
| #endif /* NAKEYLOOKUPONNASTRINGONLY_H */ |
| #endif /* USING_NAKEYLOOKUPONNASTRINGONLY */ |
