| /********************************************************************** |
| // @@@ 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 COMANSINAMEPART_H |
| #define COMANSINAMEPART_H |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: ComAnsiNamePart.h |
| * Description: An object of this class represents one part (catalog, |
| * schema, object or column) of a fully qualified ANSI |
| * name. An ANSI name part can be either a ANSI SQL |
| * regular identifier or delimited identifier. |
| * |
| * Created: 7/20/95 |
| * Language: C++ |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "Platform.h" |
| #include "NAWinNT.h" // for wchar (tcr) |
| #include <iosfwd> |
| using namespace std; |
| #include <string.h> |
| #include "ComOperators.h" |
| #include "ComSmallDefs.h" |
| #include "ComSizeDefs.h" |
| #include "NABoolean.h" |
| #include "NAString.h" |
| |
| // ----------------------------------------------------------------------- |
| // External declarations |
| // ----------------------------------------------------------------------- |
| class ComRoutineActionNamePart; |
| |
| // ----------------------------------------------------------------------- |
| // Computed internal-format column name |
| // ----------------------------------------------------------------------- |
| |
| #define DIVISION_COLUMN_NAME_PREFIX "DIVISION_" |
| #define DIVISION_COLUMN_NAME_PREFIX_LEN_IN_BYTES 9 |
| #define DIVISION_COLUMN_SEQ_NUM_MAX_LEN_IN_BYTES 10 |
| #define DIVISION_COLUMN_NAME_MAX_LEN_IN_BYTES 35 |
| #define MAX_FUNNY_NAME_LENGTH 16 |
| // 35 = 9 // DIVISION_COLUMN_NAME_PREFIX_LEN_IN_BYTES |
| // + 10 // DIVISION_COLUMN_SEQ_NUM_MAX_LEN_IN_BYTES |
| // + 16 // MAX_FUNNY_NAME_LENGTH - funny-suffix-max-len-in-bytes defined in w:/sqlshare/CatSQLShare.h |
| |
| // // InternalIdentifierHasDivColNamePrefix() returns TRUE if the internal |
| // // identifier has the DIVISION_ name prefix; otherwise, returns FALSE. |
| // NABoolean InternalIdentifierHasDivColNamePrefix (const char * internalColName); // in |
| |
| // ----------------------------------------------------------------------- |
| // Functions to convert ANSI SQL names from the current for-internal- |
| // processing character set (i.e., the Unicode UTF-8 character set) to |
| // the Unicode UCS-2/UTF-16 encoding format and vice versa. |
| // |
| // Similar APIs with char* and NAWchar* parameters in place of |
| // NAString and NAWString parameters are declared and defined |
| // in the header and source files w:/common/ComDistribution.h and |
| // .cpp for used by low-level code like the one in the source |
| // file w:/comexe/LateBindInfo.cpp which cannot use the process heap. |
| // ----------------------------------------------------------------------- |
| // returned error code described in w:/common/csconvert.h |
| Int32 ComAnsiNameToUTF8 ( const NAWString &inAnsiNameInUCS2 // in - valid ANSI SQL name in UCS2/UTF16 |
| , NAString & outBuf4AnsiNameInUTF8 // out - out buffer in UTF8 |
| ); |
| |
| // returned error code described in w:/common/csconvert.h |
| Int32 ComAnsiNameToUCS2 ( const NAString & inAnsiNameInUTF8 // in - input C string in UTF8 |
| , NAWString & outAnsiNameInUCS2 // out - out buffer containing UCS2/UTF16 chars |
| ); |
| |
| // ----------------------------------------------------------------------- |
| // definition of class ComAnsiNamePart |
| // ----------------------------------------------------------------------- |
| |
| class ComAnsiNamePart : public NABasicObject |
| { |
| |
| // |
| // global friend functions |
| // |
| |
| friend ostream& operator<< (ostream &out, const ComAnsiNamePart &name); |
| |
| public: |
| |
| // |
| // enumerations |
| // |
| |
| // Please use the enumerated constants defined in w:/common/ComSizeDefs.h |
| // instead of the following definitions for new code. |
| enum { MAX_IDENTIFIER_INT_LEN = ComMAX_1_PART_INTERNAL_UTF8_NAME_LEN_IN_BYTES, |
| MAX_IDENTIFIER_EXT_LEN = ComMAX_1_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES, |
| // nobody use this enum ... MAX_DELIMIDENT_LEN = MAX_IDENTIFIER_EXT_LEN, |
| MAX_ANSI_NAME_EXT_LEN = ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES, |
| MAX_ANSI_NAME_INT_LEN = 3 * MAX_IDENTIFIER_INT_LEN + 2, // what is this ??? |
| MAX_OLD_ANSI_IDENTIFIER_LEN = 258, // See comexe/LateBindInfo.h and BDR |
| MAX_OLD_ANSI_NAME_EXT_LEN = 776 }; // used in BDR |
| |
| // ANSI 5.2 SR 8 + 9: |
| // The first is the max number of internal characters, |
| // the second the max of external chars in a delimited identifier |
| // (the most pathological example, an ident which internally is |
| // 128 dquotes -- externally is 128 pairs of dquotes (i.e. quoted quotes) |
| // all delimited fore and aft with a dquote. |
| |
| enum formatEnum { EXTERNAL_FORMAT , |
| INTERNAL_FORMAT }; |
| |
| // EXTERNAL_FORMAT the input identifier is in external |
| // format, ANSI format, the format used by the user |
| // |
| // INTERNAL_FORMAT the input identifier is in internal |
| // format, the format stored in the |
| // schema metadata tables |
| |
| // |
| // constructors |
| // |
| |
| // Default constructor. This method creates an empty object. |
| |
| ComAnsiNamePart (CollHeap * h=0, |
| unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT); |
| |
| // copy ctor |
| ComAnsiNamePart (const ComAnsiNamePart & orig, CollHeap * h=0) ; |
| |
| ComAnsiNamePart (const NAString &name, |
| formatEnum format = EXTERNAL_FORMAT, |
| CollHeap * h=0, |
| unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT); |
| |
| // toInternalIdentifierFlags is the sames as pv_flags in ToInternalIdentifier() declared in NAString.h |
| |
| ComAnsiNamePart (const char *name, size_t nameLen, |
| formatEnum format = EXTERNAL_FORMAT, |
| CollHeap * h=0, |
| unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT); |
| |
| // Checks the input ANSI SQL name component which is in the |
| // specified format. |
| // In the first ctor, the input name component cannot contain |
| // any null character; |
| // in the second, |
| // the name component is exactly nameLen bytes long, and |
| // may contain null characters. |
| // |
| // If the input name component is legal, construct the object |
| // from the input name component; otherwise, construct an |
| // empty object. |
| |
| ComAnsiNamePart ( const NAString &externalNameParts |
| ,size_t &count |
| ,CollHeap * h=0 |
| ,NABoolean createDropalias = FALSE |
| ,NABoolean acceptCircumflex = FALSE |
| ,unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT |
| ); |
| |
| ComAnsiNamePart (const char *externalNameParts, |
| size_t externalNPLen, |
| size_t &count, |
| CollHeap * h=0, |
| unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT); |
| |
| // Scans (parses) the specified input string |
| // for an external-format ANSI SQL name part. |
| // |
| // The first character in the input string must be the first |
| // character of the name part. Note that the input string |
| // can include other input besides the name part. |
| // |
| // The method copies the name part if it is found, and |
| // returns the length of the scanned name part via the |
| // parameter count. The method also computes the corre- |
| // sponding internal-format name part and stores the |
| // computed internal name. |
| // |
| // If the name part is not found or is illegal (for example, |
| // the name part is too long), the method returns the number |
| // of bytes examined when the identifier is determined |
| // to be invalid, and constructs an empty object. |
| |
| // |
| // virtual destructor |
| // |
| virtual ~ComAnsiNamePart (); |
| |
| // |
| // virtual cast functions |
| // |
| virtual ComRoutineActionNamePart * castToComRoutineActionNamePart(); |
| virtual const ComRoutineActionNamePart * castToComRoutineActionNamePart() const; |
| |
| // |
| // type conversion operator |
| // |
| operator const char * () const { return (const char *)externalName_; } |
| |
| // Returns a pointer to the external-format ANSI SQL name component. |
| |
| // |
| // assignment operators |
| // |
| |
| ComAnsiNamePart& operator= (const ComAnsiNamePart& ); |
| ComAnsiNamePart& operator= (const NAString &externalName); |
| |
| // The specified external name on the right-hand side |
| // must be a valid ANSI SQL name component, in external |
| // format. If not, this object (on the left-hand side) |
| // will be cleared. |
| |
| // |
| // logical operator |
| // |
| NABoolean operator== (const ComAnsiNamePart &rhs) const; |
| |
| inline Int32 compareTo (const ComAnsiNamePart &rhs) const; |
| |
| // |
| // accessors |
| // |
| |
| // Use these two methods only if input strings have been parsed. |
| void setExternalName (const NAString &name) { externalName_ = name; } |
| void setInternalName (const NAString &name) { internalName_ = name; } |
| |
| const NAString &getData () const { return externalName_; } |
| |
| const NAString &getExternalName () const { return externalName_; } |
| |
| // Returns the ANSI SQL name component, in external format. |
| |
| const NAString &getInternalName () const { return internalName_; } |
| |
| // Returns the ANSI SQL name component, in internal format, |
| // without padded trailing white spaces. |
| |
| NABoolean isEmpty () const { return externalName_.isNull(); } |
| |
| NABoolean isValid () const { return NOT isEmpty(); } |
| |
| // The method returns TRUE if the object contains a legal |
| // ANSI SQL name component. The method returns FALSE if |
| // the object is empty (does not contain an ANSI SQL name |
| // component). An object is empty if it is created by |
| // the default constructor or the input ANSI SQL name |
| // component is illegal. |
| |
| NABoolean isDelimitedIdentifier () const; |
| |
| // The method returns TRUE if the ANSI SQL name component |
| // (identifier) is a delimited identifier. The method |
| // returns FALSE if the identifier is invalid or is not a |
| // delimited identifier. |
| |
| // |
| // mutators |
| // |
| |
| void clear() { externalName_ = internalName_ = ""; } |
| |
| // Makes this object an empty object. |
| |
| |
| private: |
| |
| // --------------------------------------------------------------------- |
| // private methods |
| // --------------------------------------------------------------------- |
| |
| NABoolean scanAnsiNamePart ( const NAString &externalNameParts |
| , size_t &count |
| , NABoolean createDropAlias = FALSE |
| , NABoolean acceptCircumflex = FALSE |
| , unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT |
| ); |
| |
| // This method scans (parses) for one external-format ANSI |
| // SQL name part in the (possibly multi-part) input string. |
| // That is, given "xx.yy.zz", the name is set to XX and the |
| // count returns as 2. |
| // |
| // The method returns TRUE if the name part is found, and |
| // returns the length of the scanned name part, and sets |
| // the corresponding internal-format name; otherwise, the |
| // method returns FALSE. |
| // |
| // The syntax of ANSI SQL name part is defined on page 78 |
| // of the ANSI X3H2-93-004 (also known as SQL-92) standard. |
| // The ANSI SQL name component is referred to as |
| // <actual identifier> in the standard. |
| // |
| // externalNameParts IN |
| // |
| // This parameter contains the input string containing an |
| // external-format ANSI SQL actual identifier. |
| // |
| // count IN OUT |
| // |
| // This param's IN value must be either 0 (scan entire NAString) |
| // or 1 (scan till bad character) is described in more detail |
| // in the .cpp file. |
| // |
| // The length, in bytes, of the scanned name component is |
| // returned via this parameter. If an error occurs, this |
| // parameter contains the number of characters examined |
| // when the identifier is determined to be invalid. |
| // Any separating dot is not included in this count. |
| // |
| // NABoolean createDropAlias = FALSE IN |
| // |
| // NABoolean acceptCircumflex = FALSE IN |
| // |
| // unsigned short toInternalIdentifierFlags = NASTRING_ALLOW_NSK_GUARDIAN_NAME_FORMAT |
| // IN |
| // |
| // Same as the pv_flags parameter in ToInternalIdentifier() routine |
| // |
| // data member this->externalName_ OUT |
| // data member this->internalName_ OUT |
| // |
| // The method puts the internal-format name computed from |
| // the scanned externalNameParts into data member internalName_. |
| // If an error occurs, internalName_ contains an empty string. |
| |
| NABoolean copyExternalName (const NAString &externalName); |
| NABoolean copyInternalName (const NAString &internalName); |
| |
| // --------------------------------------------------------------------- |
| // private data members |
| // --------------------------------------------------------------------- |
| |
| NAString externalName_; |
| NAString internalName_; |
| |
| CollHeap * heap_; |
| |
| public: |
| unsigned short toInternalIdentifierFlags_; |
| |
| }; // class ComAnsiNamePart |
| |
| // ----------------------------------------------------------------------- |
| // definitions of inline methods |
| // ----------------------------------------------------------------------- |
| |
| Int32 ComAnsiNamePart::compareTo (const ComAnsiNamePart &rhs) const |
| { |
| if (this EQU &rhs) return 0; |
| else return internalName_.compareTo (rhs.internalName_); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // declaration of function ComDeriveRandomInternalName |
| // ----------------------------------------------------------------------- |
| |
| ComBoolean ComDeriveRandomInternalName( Lng32 nameCharSet, |
| const ComString &inputNameInInternalFormat, |
| ComString &generatedNameInInternalFormat, |
| NAHeap *h = 0 ); |
| |
| ComBoolean ComIsRandomInternalName(const ComString &inputName); |
| |
| #endif // COMANSINAMEPART_H |
