/**********************************************************************
// @@@ 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 CHARTYPE_H
#define CHARTYPE_H
/* -*-C++-*-
**************************************************************************
*
* File:         CharType.h
* Description:  Character Type
* Created:      4/27/94
* Language:     C++
*
*
**************************************************************************
*/


#include <limits.h>
#include "BaseTypes.h"
// Some ANSI compilers require this function to be declared even though
// the template NAKeyLookup is not instantiated (that class template is a
// subclass of NAHashDictionary ... in /common/Collections.h )
Lng32 hashKey();  // a dummy -- hopefully the linker won't look for it ...
#include "NAType.h"
#include "str.h"
#include "nawstring.h"
#include "charinfo.h"
#include "ExpLOBenums.h"
// -----------------------------------------------------------------------
// contents of this file
// -----------------------------------------------------------------------
class CharLenInfo;
class CharType;
class SQLChar;
class SQLVarChar;
class AnsiChar;
class SQLLongVarChar;


// ***********************************************************************
//
//  CharLenInfo : Information about the length of the character data type
//
// ***********************************************************************
class CharLenInfo
{
public:

  CharLenInfo () : maxLenInChars_(0), maxLenInBytes_(0) {}
  CharLenInfo (const CharLenInfo & rhs) : maxLenInChars_(rhs.maxLenInChars_)
                                        , maxLenInBytes_(rhs.maxLenInBytes_)
                                          {}
  CharLenInfo (const Int32 maxLenInChars, const Int32 maxLenInBytes)
    : maxLenInChars_(maxLenInChars), maxLenInBytes_(maxLenInBytes) {}

  ~CharLenInfo () {}

  Int32 getMaxLenInChars () const { return maxLenInChars_; }
  Int32 getMaxLenInBytes () const { return maxLenInBytes_; }
  
  void setMaxLenInChars (Int32 maxLenInChars) { maxLenInChars_ = maxLenInChars; }
  void setMaxLenInBytes (Int32 maxLenInBytes) { maxLenInBytes_ = maxLenInBytes; }

private:

  Int32 maxLenInChars_; // for UCS2, # of UCS2 elements - for other, # of real (e.g., UCS4) characters
  Int32 maxLenInBytes_; // count in bytes - important when cs is a variable-length mbcs like UTF-8

};

// ***********************************************************************
//
//  CharType : The character data type
//
// ***********************************************************************
class CharType : public NAType
{
public:

// ---------------------------------------------------------------------
// ## Future work is required to encapsulate and process information for
// ## Collations, Translations, Character Set Specifications/Repertoires.
// ## See CharType::computeNextKeyValue() for an example of one method
// ## (at least) that needs rework to handle these things.
// ---------------------------------------------------------------------

// CharType was designed for column declaration. However, we have extend the 
// character set & collate clauses to SCHEMA & CATALOG. Adding them to the adtName list, which
// doesn't seem to serve any purpose, as far as I can tell. 
static const NAString LiteralSchema;
static const NAString LiteralCatalog;

// ---------------------------------------------------------------------
// Constructor functions
// ---------------------------------------------------------------------
CharType (NAMemory *h,
          const NAString&	adtName, 
	  Lng32		maxCharStrLen,
	  short		bytesPerChar = 0,
	  NABoolean	nullTerminated = FALSE,
	  NABoolean	allowSQLnull   = TRUE,
	  NABoolean	isUpShifted    = FALSE,
	  NABoolean     isCaseInsensitive = FALSE,
	  NABoolean	varLenFlag     = FALSE,
	  CharInfo::CharSet      cs = CharInfo::DefaultCharSet,
	  CharInfo::Collation    co = CharInfo::DefaultCollation,
	  CharInfo::Coercibility ce = CharInfo::COERCIBLE,
	  CharInfo::CharSet      encoding = CharInfo::UnknownCharSet,
	  Lng32 vcIndLen = 0  // not passed in, need to be computed
         );
CharType (NAMemory *h,
          const NAString&  adtName,
          const CharLenInfo & maxLenInfo,
          short            /*max*/bytesPerChar = 0, // is maxBytesPerChar when cs is SJIS or UTF8
          NABoolean        nullTerminated = FALSE,
          NABoolean        allowSQLnull = TRUE,
          NABoolean        isUpShifted = FALSE,
          NABoolean        isCaseInsensitive = FALSE,
          NABoolean        varLenFlag = FALSE,
          CharInfo::CharSet      cs = CharInfo::DefaultCharSet,
          CharInfo::Collation    co = CharInfo::DefaultCollation,
          CharInfo::Coercibility ce = CharInfo::COERCIBLE,
          CharInfo::CharSet      encoding = CharInfo::UnknownCharSet
          );
// copy ctor
CharType (const CharType& charType,NAMemory * heap):
NAType(charType,heap),
	qualifier_	(CHARACTER_STRING_TYPE),
	bytesPerChar_	(charType.bytesPerChar_),
	charLimitInUCS2or4chars_ (charType.charLimitInUCS2or4chars_),
	nullTerminated_ (charType.nullTerminated_),
	upshifted_	(charType.upshifted_),
	caseinsensitive_(charType.caseinsensitive_),
	charSet_	(charType.charSet_),
	collation_	(charType.collation_),
	coercibility_	(charType.coercibility_),
	encodingCharSet_(charType.encodingCharSet_)
{}
virtual short getFSDatatype() const;
virtual Lng32 getPrecisionOrMaxNumChars() const;
virtual Lng32 getScaleOrCharset() const;

// ---------------------------------------------------------------------
// Accessor functions
// ---------------------------------------------------------------------
virtual CharInfo::CharSet      getCharSet() const	{ return charSet_; }
CharInfo::Collation    getCollation() const	{ return collation_; }
CharInfo::Coercibility getCoercibility() const	{ return coercibility_; }
CharInfo::CharSet      getEncodingCharSet() const { return encodingCharSet_; }

void setCharSet(CharInfo::CharSet cs)	{ charSet_ = cs; }
void setEncodingCharSet(CharInfo::CharSet cs)	{ encodingCharSet_ = cs; }
void setCollation(CharInfo::Collation co)	{ collation_ = co; }
void setCoercibility(CharInfo::Coercibility ce)	{ if (ce == CharInfo::IMPLICIT)
						    ce = CharInfo::COERCIBLE;
						  coercibility_ = ce;
						}
void setCoAndCo(CharInfo::Collation co,
		CharInfo::Coercibility ce)	{ setCollation(co);
						  setCoercibility(ce);
						}

void  setBytesPerChar(short BpC)		{ bytesPerChar_ = BpC ; }
short getBytesPerChar() const 			{ return bytesPerChar_; }
NABoolean isNullTerminated() const 		{ return nullTerminated_; }
NABoolean isUpshifted() const 			{ return upshifted_; }
void	 setUpshifted(NABoolean us)		{ upshifted_ = us; }
NABoolean isCaseinsensitive() const 		{ return caseinsensitive_; }
void	 setCaseinsensitive(NABoolean ci)	{ caseinsensitive_ = ci; }
void setDataStorageSize(Lng32 size) 
{
  dataStorageSize_ = size;
}
Lng32 getDataStorageSize() const
{
  return dataStorageSize_;
}
Lng32 getStrCharLimit() const
{
  if ( getNominalSize() > 0  &&  getCharLimitInUCS2or4chars() > 0 &&
       ( getCharSet() == CharInfo::UTF8 ) )
    return getCharLimitInUCS2or4chars();

  if ( getCharSet() == CharInfo::UNICODE )
     return getNominalSize() / getBytesPerChar();
  else
     return getNominalSize();
}
Lng32 getMaxLenInBytesOrNAWChars() const
{
    if ( getCharSet() == CharInfo::UNICODE )
       return getNominalSize() / getBytesPerChar();
    else
       return getNominalSize();
}

Lng32 getCharLimitInUCS2or4chars() const { return charLimitInUCS2or4chars_; }

// Useful for testing compatibility with double-byte char's
NABoolean sizeIsEven() const
{ Lng32 rem = getNominalSize() % 2;
  if (isNullTerminated() && getBytesPerChar() == 1) return (rem == 1);
  return (rem == 0);
}

// the blank character is used to fill strings when comparing strings of
// different length or when converting a shorter string to a longer one
virtual Lng32 getBlankCharacterValue() const;

// get the smallest and the greatest single character in this
// character set and collation
Lng32 getMinSingleCharacterValue() const;
Lng32 getMaxSingleCharacterValue() const;

// encode a string into a double precision, preserving the order of values
double encodeString (const char *str,Lng32 strLen) const;

NAString* convertToString(double v, NAMemory * h) const;

// ---------------------------------------------------------------------
// Virtual functions that are given an implementation for this class.
// ---------------------------------------------------------------------
virtual NABoolean computeNextKeyValue(NAString &keyValue) const;
virtual NABoolean computeNextKeyValue(NAWString &keyValue) const;
virtual NABoolean computeNextKeyValue_UTF8(NAString &keyValue) const;

virtual NAString getTypeSQLname(NABoolean terse = FALSE) const;

virtual NAString getSimpleTypeName() const;

virtual NAString* getKey(CollHeap* h=0) const; // compute hash key from SQL name

virtual NABoolean operator==(const NAType& other) const;

// compares sttributes specific to char datatypes
virtual NABoolean compareCharAttrs(const NAType& other) const;

virtual NABoolean isCompatible(const NAType& other, UInt32 * flags = NULL) const;

#ifndef CLI_SRL
virtual NABoolean isComparable(const NAType &other,
			       ItemExpr *parentOp,
			       Int32 emitErr = EmitErrAlways,
                               UInt32 * flags = NULL) const;
#endif
  
NABoolean isCharSetAndCollationComboOK() const;
NABoolean isCompatibleAllowUnknownCharset(const NAType& other) const;

// ---------------------------------------------------------------------
// A virtual function for synthesizing the type of a binary operator.
// ---------------------------------------------------------------------
virtual const NAType* synthesizeType(NATypeSynthRuleEnum synthRule,
                                     const NAType& operand1,
                                     const NAType& operand2,
				     CollHeap* h,
				     UInt32 *flags = NULL) const;

// ---------------------------------------------------------------------
// Print function for debugging
// ---------------------------------------------------------------------
virtual void print(FILE *ofd = stdout, const char *indent = DEFAULT_INDENT);

// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
virtual NAType *newCopy(NAMemory* h=0) const { return new(h) CharType(*this,h); }

// A virtual function to return a varchar equivalent of this type
virtual NAType *equivalentVarCharType
  (NAMemory *h, NABoolean quantizeLen=FALSE) { return this; }
virtual NAType *equivalentCharType
  (NAMemory *h, NABoolean quantizeLen=FALSE) { return this; }

// ---------------------------------------------------------------------
// Need encoding for Unicode charset. // 7/27/98
// See NAType.h for a description on this method.
// ---------------------------------------------------------------------
NABoolean isEncodingNeeded() const;

// ---------------------------------------------------------------------
// A method which tells if a conversion error can occur when converting
// a value of this type to the target type.
// ---------------------------------------------------------------------
NABoolean errorsCanOccur (const NAType& target, NABoolean lax=TRUE) const;

// ---------------------------------------------------------------------
// Compute the collating sequence and coercibility for dyadic operators
// ---------------------------------------------------------------------
NABoolean computeCoAndCo(const CharType& other,
			 CharInfo::Collation& co,
			 CharInfo::Coercibility& ce) const;

// ---------------------------------------------------------------------
// Get the char type information as NAString. 
// ---------------------------------------------------------------------
NAString getCharSetName() const;
NAString getEncodingCharSetName() const;
NAString getCollationName() const;

NAString getCharSetAsPrefix() const;
static
NAString getCharSetAsPrefix(CharInfo::CharSet cs);
static
NAString getCollateClause(CharInfo::Collation co);
static
NAString getCoercibilityText(CharInfo::Coercibility ce);

// ---------------------------------------------------------------------
// CharSet info inference
// ---------------------------------------------------------------------
static const CharType*
findPushDownCharType(CharInfo::CharSet, const CharType*, ...);
static const CharType* desiredCharType(enum CharInfo::CharSet);

// -----------------------------------------------------------------------
// CHARACTER SET UTF8 character data type
// -----------------------------------------------------------------------
void generateTextThenSetDisplayDataType ( CharInfo::CharSet cs                   // in
                                        , NAString & ddt                         // in/out
                                        );

virtual NABoolean createSQLLiteral(const char * buf,
                                   NAString *&sqlLiteral,
                                   NABoolean &isNull,
                                   CollHeap *h) const;

protected:
void minMaxRepresentableValue(void* bufPtr,
                              Lng32* bufLen,
                              NAString ** stringLiteral,
                              NABoolean isMax,
                              CollHeap* h) const;

private:

void NONVIRT_METHOD_PLACEHOLDER_1();	// slot for reuse, or delete it!##

NABoolean operator=(const CharType& other);	// assignmentOp, not implemented

// ---------------------------------------------------------------------
// Declaration for different data type names that are used internally.
//##	There is only one type being used currently -- CHARACTER_STRING_TYPE.
//##	If more values are added to this, then the CharType methods
//##	  operator==()  isCompatible()  isComparable()
//##	may or may not need to be changed to use the CharTypeEnum qualifier_
//##	as a discriminant...
// ---------------------------------------------------------------------
enum CharTypeEnum 
{  
  MIN_CHAR_TYPE   
, CHARACTER_STRING_TYPE 
, MAX_CHAR_TYPE
};

// ---------------------------------------------------------------------
// Definition of variable for storing internal form names.
//##	See note at "enum CharTypeEnum" above.
// ---------------------------------------------------------------------
CharTypeEnum  qualifier_;  

// ---------------------------------------------------------------------
// Number of bytes per character - For variable-length multi-byte
// character sets like UTF8 (a character may take 1, 2, 3 or 4 bytes),
// this field contains the maximum number of bytes per character.
// ---------------------------------------------------------------------
short  /*max*/bytesPerChar_;
 
// ---------------------------------------------------------------------
// --- Maximum size in UCS2 or UCS4 characters ----
// For getCharSet() == CharInfo::UCS2, the unit is UCS2 (or NAWchar),
//     and surrogate pair has a count of 2 NAWchar(acters).
// For variable-length multi-byte character sets like SJIS and UTF8,
//     the unit is UCS4 (the actual character specified by the user).
// Set this field to -1 if it is not used.
// ---------------------------------------------------------------------
Lng32  charLimitInUCS2or4chars_;
 
// ---------------------------------------------------------------------
// TRUE if these character strings are terminated using C nul character
// (either byte or double-byte).  Implies no varLen header word.
// ---------------------------------------------------------------------
NABoolean  nullTerminated_;

// ---------------------------------------------------------------------
// Flag indicating whether or not the string is "upshifted". 
// ---------------------------------------------------------------------
NABoolean  upshifted_;
 
// ---------------------------------------------------------------------
// Flag indicating whether or not the string is "caseinsensitive". 
// ---------------------------------------------------------------------
NABoolean  caseinsensitive_;
 
CharInfo::CharSet charSet_;
CharInfo::Collation collation_;
CharInfo::Coercibility coercibility_;
CharInfo::CharSet encodingCharSet_;

}; // class CharType


// ***********************************************************************
//
//  SQLChar : SQL CHARACTER
//
// ***********************************************************************
class SQLChar : public CharType
{
public:
// ---------------------------------------------------------------------
// Constructor functions 
// ---------------------------------------------------------------------
  SQLChar (NAMemory *h,
           Lng32 maxLength, 
	   NABoolean allowSQLnull	= TRUE,
	   NABoolean isUpShifted	= FALSE, 
	   NABoolean     isCaseInsensitive = FALSE,
	   NABoolean varLenFlag		= FALSE,
	   CharInfo::CharSet		= CharInfo::DefaultCharSet,
	   CharInfo::Collation		= CharInfo::DefaultCollation,
	   CharInfo::Coercibility	= CharInfo::COERCIBLE,
	   CharInfo::CharSet encoding	= CharInfo::UnknownCharSet
          );
  SQLChar (NAMemory *h,
           const CharLenInfo & maxLenInfo,
	   NABoolean allowSQLnull	= TRUE,
	   NABoolean isUpShifted	= FALSE, 
	   NABoolean isCaseInsensitive	= FALSE,
	   NABoolean varLenFlag		= FALSE,
	   CharInfo::CharSet		= CharInfo::DefaultCharSet,
	   CharInfo::Collation		= CharInfo::DefaultCollation,
	   CharInfo::Coercibility	= CharInfo::COERCIBLE,
	   CharInfo::CharSet encoding	= CharInfo::UnknownCharSet
          );
//copy ctor
	SQLChar (const SQLChar & sqlChar,
		NAMemory * heap):CharType(sqlChar,heap)
	{}
short getFSDatatype() const;

// ---------------------------------------------------------------------
// Methods that return the binary form of the minimum and the maximum
// representable values.
// ---------------------------------------------------------------------
virtual void minRepresentableValue(void*, Lng32*, 
				     NAString** stringLiteral = NULL,
				     CollHeap* h=0) const;
virtual void maxRepresentableValue(void*, Lng32*, 
				     NAString** stringLiteral = NULL,
				     CollHeap* h=0) const;
// get the encoding of the max char value
double getMaxValue() const;

// get the encoding of the min char value
double getMinValue() const;

virtual double encode (void*) const;
// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
virtual NAType *newCopy(NAMemory * h=0) const { return new(h) SQLChar(*this,h); }
 
// A virtual function to return a varchar equivalent of this type
virtual NAType *equivalentVarCharType
  (NAMemory *h, NABoolean quantizeLen=FALSE);

private:
}; // class SQLChar


// ***********************************************************************
//
//  SQLVarChar : SQL CHARACTER VARYING
//
// ***********************************************************************
class SQLVarChar : public CharType
{
public:
// ---------------------------------------------------------------------
// Constructor functions 
// ---------------------------------------------------------------------
  SQLVarChar(NAMemory *h,
             Lng32 maxLength,
 	     NABoolean allowSQLnull	= TRUE,
	     NABoolean isUpShifted	= FALSE,
	     NABoolean isCaseInsensitive = FALSE,
	     CharInfo::CharSet		= CharInfo::DefaultCharSet, 
	     CharInfo::Collation	= CharInfo::DefaultCollation,
	     CharInfo::Coercibility	= CharInfo::COERCIBLE,
	     CharInfo::CharSet encoding	= CharInfo::UnknownCharSet,
             Lng32 vcIndLen             = 0
	    );
  SQLVarChar(NAMemory *h,
             const CharLenInfo & maxLenInfo,
	     NABoolean allowSQLnull	= TRUE,
	     NABoolean isUpShifted	= FALSE,
	     NABoolean isCaseInsensitive = FALSE,
	     CharInfo::CharSet		= CharInfo::DefaultCharSet, 
	     CharInfo::Collation	= CharInfo::DefaultCollation,
	     CharInfo::Coercibility	= CharInfo::COERCIBLE,
	     CharInfo::CharSet encoding	= CharInfo::UnknownCharSet
	    );

  SQLVarChar(const SQLChar &fixed);
//copy ctor
  SQLVarChar(const SQLVarChar& varChar, NAMemory * heap):
				CharType(varChar,heap),
				clientDataType_(varChar.getClientDataTypeName(),heap),
                                wasHiveString_(varChar.wasHiveString())
				{}
virtual void minRepresentableValue(void*, Lng32*,
				     NAString** stringLiteral = NULL,
				     CollHeap* h=0) const;
virtual void maxRepresentableValue(void*, Lng32*,
				     NAString** stringLiteral = NULL,
				     CollHeap* h=0) const;

// True FS data type is the type that the object gets in the sqlparser.
// That type usually the same through out the life span of the object: from 
// the compiler to the executor. For LONGWVARCHAR, the fs type is 
// REC_BYTE_V_ASCII_LONG as assigned by the parser, and that type is later 
// changed to REC_NCHAR_V_UNICODE. 
// 
// This new method allows the reuse of code for REC_NCHAR_V_UNICODE for
// REC_BYTE_V_ASCII_LONG.
virtual short getTrueFSDatatype() const { return getFSDatatype();};
virtual short getFSDatatype() const;

virtual double encode (void*) const;

virtual NABoolean isEncodingNeeded() const	{ return TRUE; }

virtual NABoolean operator==(const NAType& other) const;

// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
virtual NAType *newCopy(NAMemory* h=0) const { return new(h) SQLVarChar(*this,h); }
// A virtual function to return a char equivalent of this type
virtual NAType *equivalentCharType
(NAMemory *h, NABoolean quantizeLen=FALSE);

NAString getClientDataTypeName() const
{ return clientDataType_.isNull() ? getSimpleTypeName() : clientDataType_; }

void setClientDataType(NAString clientName) { clientDataType_ = clientName; }

NABoolean wasHiveString() const {return wasHiveString_;}
void setWasHiveString(NABoolean v) { wasHiveString_ = v;}
private:

  NAString clientDataType_;

  // if original datatype was hive 'string' type
  NABoolean wasHiveString_;

}; // class SQLVarChar


// ***********************************************************************
//
//  ANSIChar : ANSI CHARACTER
//              Null terminated string. Not supported internally.
//              Valid for application hostvar and params only.
//
// ***********************************************************************
class ANSIChar : public CharType
{
public:
// ---------------------------------------------------------------------
// Constructor functions 
// ---------------------------------------------------------------------
 ANSIChar (NAMemory *h,
           Lng32 maxLength,
 	   NABoolean allowSQLnull	= TRUE,
	   NABoolean isUpShifted	= FALSE,
	   NABoolean varLenFlag		= FALSE,
           CharInfo::CharSet		= CharInfo::DefaultCharSet, 
           CharInfo::Collation		= CharInfo::DefaultCollation,
           CharInfo::Coercibility	= CharInfo::COERCIBLE,
	   CharInfo::CharSet encoding	= CharInfo::UnknownCharSet 
	  );
 ANSIChar(const ANSIChar& ansiChar,NAMemory * heap):
			CharType(ansiChar,heap)
			{}
 short getFSDatatype() const;

NABoolean isExternalType() const 	{ return TRUE; }

NAType * equivalentType(CollHeap* h=0) const
{
  return new(h) SQLVarChar(h, getNominalSize(), supportsSQLnull(),
			     isUpshifted(), FALSE, getCharSet(), getCollation(),
                           getCoercibility());
}

// A virtual function to return a varchar equivalent of this type
virtual NAType *equivalentVarCharType
  (NAMemory *h, NABoolean quantizeLen=FALSE);
virtual NAType *equivalentCharType
  (NAMemory *h, NABoolean quantizeLen=FALSE) { return NULL; }

// ---------------------------------------------------------------------
// Methods that returns the binary form of the minimum and the maximum
// representable values.
// ---------------------------------------------------------------------
virtual void minRepresentableValue(void*, Lng32*, 
				     NAString** /*stringLiteral*/ = NULL,
                                   CollHeap* = 0) const
{};

virtual void maxRepresentableValue(void*, Lng32*, 
				     NAString** /*stringLiteral*/ = NULL,
                                   CollHeap* = 0) const
{};

virtual double encode (void*) const 	{return 0E0;}

// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
virtual NAType *newCopy(NAMemory* h=0) const { return new(h) ANSIChar(*this,h); }
 
private:

}; // class ANSIChar


// **********************************************************************
// 
// SQLLONGVARCHAR: SQLVARCHAR
// Purpose: This class was added to provide support for the OBDC datatype.
// 
// **********************************************************************

class SQLLongVarChar : public SQLVarChar
{

public: 

 SQLLongVarChar(NAMemory *h,
                Lng32 maxLength, 
		NABoolean validLength	   = FALSE, 
		NABoolean allowSQLnull	   = TRUE,
		NABoolean isUpShifted	   = FALSE,
		NABoolean isCaseInsensitive = FALSE,
		CharInfo::CharSet cs	   = CharInfo::DefaultCharSet, 
		CharInfo::Collation co	   = CharInfo::DefaultCollation,
		CharInfo::Coercibility ce  = CharInfo::COERCIBLE,
		CharInfo::CharSet encoding = CharInfo::UnknownCharSet
	       )
  : SQLVarChar(h, maxLength, allowSQLnull, isUpShifted, isCaseInsensitive,
	       cs, co, ce)
  {
    setClientDataType("LONG VARCHAR");
    lengthNotSet_ = !validLength;
  }
 SQLLongVarChar(NAMemory *h,
                const CharLenInfo & maxLenInfo,
		NABoolean validLength	   = FALSE, 
		NABoolean allowSQLnull	   = TRUE,
		NABoolean isUpShifted	   = FALSE,
		NABoolean isCaseInsensitive = FALSE,
		CharInfo::CharSet cs	   = CharInfo::DefaultCharSet, 
		CharInfo::Collation co	   = CharInfo::DefaultCollation,
		CharInfo::Coercibility ce  = CharInfo::COERCIBLE,
		CharInfo::CharSet encoding = CharInfo::UnknownCharSet
	       )
  : SQLVarChar(h, maxLenInfo, allowSQLnull, isUpShifted, isCaseInsensitive,
	       cs, co, ce)
  {
    setClientDataType("LONG VARCHAR");
    lengthNotSet_ = !validLength;
  }
 SQLLongVarChar(const SQLLongVarChar & aLongVarChar,NAMemory * heap)
	 :SQLVarChar(aLongVarChar,heap),
	 lengthNotSet_(aLongVarChar.isLengthNotSet())
 {}
 virtual short getTrueFSDatatype() const;
 virtual short getFSDatatype() const;

// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
 virtual NAType *newCopy(NAMemory* h=0) const
 					{ return new(h) SQLLongVarChar(*this,h); }

 NABoolean isLengthNotSet() const 	{ return lengthNotSet_; }

 void setLength(Lng32 size)
 {
   dataStorageSize_ = size;
   lengthNotSet_ = FALSE;
 }

private:
 NABoolean lengthNotSet_; 

}; // class SQLLongVarChar


// **********************************************************************
// 
// SQLLOB: 
// Purpose: This class was added to provide support for the LOB datatype.
// 
// **********************************************************************

class SQLlob : public NAType
{

public: 

  SQLlob(NAMemory *h,
         NABuiltInTypeEnum  ev,
	 Int64 lobLength=1024, 
	 LobsStorage lobStorage=Lob_Invalid_Storage,
	 NABoolean allowSQLnull	= TRUE,
	 NABoolean inlineIfPossible = FALSE,
	 NABoolean externalFormat = FALSE,
	 Lng32 extFormatLen=1024 );
 SQLlob(const SQLlob & aLob,NAMemory * heap)
   :NAType(aLob,heap)
    {
      lobLength_ = aLob.lobLength_;
      lobStorage_ = aLob.lobStorage_;
      externalFormat_ = aLob.externalFormat_;
      extFormatLen_ = aLob.extFormatLen_;     
      setCharSet(CharInfo::ISO88591);//lobhandle can only be in ISO format
    }
  
 //is this type a blob/clob
 virtual NABoolean isLob() const {return TRUE;};
 
 // ---------------------------------------------------------------------
 // A method which tells if a conversion error can occur when converting
 // a value of this type to the target type.
 // ---------------------------------------------------------------------
 NABoolean errorsCanOccur (const NAType& target, NABoolean lax=TRUE) const;
 
 // ---------------------------------------------------------------------
 // A name that expresses the characteristics of the type.
 // ---------------------------------------------------------------------
 virtual NAString getTypeSQLname(NABoolean terse = FALSE) const;
 
 Int64 getLobLength() {return lobLength_;}
 Lng32 extFormatLen() { return extFormatLen_; }

 virtual Lng32 getPrecision() const { return (Lng32)lobLength_; }

 virtual CharInfo::CharSet getCharSet() const	{ return charSet_; }
 void setCharSet(CharInfo::CharSet cs)
 {
   charSet_ = cs;
 }
 LobsStorage getLobStorage() {return lobStorage_;}
  NABoolean isExternal() { return externalFormat_;}
private:
 Int64 lobLength_;
 
 NABoolean externalFormat_;

 Lng32 extFormatLen_;

 NABoolean inlineIfPossible_;

 CharInfo::CharSet charSet_;
 LobsStorage lobStorage_;
}; // class SQLlob

// **********************************************************************
// 
// SQLBLOB: 
// Purpose: This class was added to provide support for the BLOB datatype.
// 
// **********************************************************************

class SQLBlob : public SQLlob
{

public: 

  SQLBlob(NAMemory *h,
          Int64 blobLength=1024, 
	  LobsStorage lobStorage = Lob_Invalid_Storage,
	  NABoolean allowSQLnull	= TRUE,
	  NABoolean inlineIfPossible = FALSE,
	  NABoolean externalFormat = FALSE,
	  Lng32 extFormatLen = 1024);
 SQLBlob(const SQLBlob & aBlob,NAMemory * heap)
      :SQLlob(aBlob,heap)
    {}
  virtual short getFSDatatype() const
  {return REC_BLOB;}
  
// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
 virtual NAType *newCopy(NAMemory* h=0) const;
 
 const NAType* synthesizeType(NATypeSynthRuleEnum synthRule,
			      const NAType& operand1,
			      const NAType& operand2,
			      CollHeap* h,
			      UInt32 *flags) const;

private:

}; // class SQLBlob

// **********************************************************************
// 
// SQLCLOB: 
// Purpose: This class was added to provide support for the CLOB datatype.
// 
// **********************************************************************

class SQLClob : public SQLlob
{

public: 

  SQLClob(NAMemory *h,
          Int64 blobLength=1024, 
	  LobsStorage lobStorage = Lob_Invalid_Storage,
	  NABoolean allowSQLnull	= TRUE,
	  NABoolean inlineIfPossible = FALSE,
	  NABoolean externalFormat = FALSE,
	  Lng32 extFormatLen = 1024);
 SQLClob(const SQLClob & aClob,NAMemory * heap)
      :SQLlob(aClob,heap)
    {}
  virtual short getFSDatatype() const
  {return REC_CLOB;}
  
// ---------------------------------------------------------------------
// A virtual function to return a copy of the type.
// ---------------------------------------------------------------------
 virtual NAType *newCopy(NAMemory* h=0) const;
 
 const NAType* synthesizeType(NATypeSynthRuleEnum synthRule,
			      const NAType& operand1,
			      const NAType& operand2,
			      CollHeap* h,
			      UInt32 *flags) const;

private:

}; // class SQLClob


#endif /* CHARTYPE_H */