////////////////////////////////////////////
// get the name of a SQL object id in locale.
////////////////////////////////////////////
SQLCLI_LIB_FUNC
char* getIdInLocale(SQLCLI_OBJ_ID* x)
{
if ( x == 0 ) return 0;
const char* charset = getIdCharSet(x);
if ( charset == CharInfo::getLocaleCharSetAsString() )
return (char*) x -> identifier;
NAWchar* nameInWchar = getIdInWchar(x);
if (nameInWchar == 0)
return 0;
#pragma nowarn(1506) // warning elimination
Int32 wcNameLen = NAWstrlen(nameInWchar);
#pragma warn(1506) // warning elimination
static char* nameInLocale = new char[MAX_CHAR_SET_STRING_LENGTH+1];
Lng32 nameInLocaleLen = UnicodeStringToLocale(CharInfo::getCharSetEnum(charset),
nameInWchar, wcNameLen,
nameInLocale, MAX_CHAR_SET_STRING_LENGTH+1);
if ( nameInLocaleLen == 0 )
return 0;
return nameInLocale;
}
////////////////////////////////////////////
// get the name of a SQL module id in locale.
////////////////////////////////////////////
SQLCLI_LIB_FUNC
char* getModNameInLocale(const SQLMODULE_ID* m)
{
if ( m == 0 ) return 0;
const char* charset = getModCharSet(m);
if ( charset == CharInfo::getLocaleCharSetAsString() )
return (char *)m -> module_name;
NAWchar* nameInWchar = getModNameInWchar(m);
if (nameInWchar == 0)
return 0;
#pragma nowarn(1506) // warning elimination
Int32 wcNameLen = NAWstrlen(nameInWchar);
#pragma warn(1506) // warning elimination
static char* nameInLocale = new char[MAX_CHAR_SET_STRING_LENGTH+1];
Lng32 x = UnicodeStringToLocale(CharInfo::getCharSetEnum(charset),
nameInWchar, wcNameLen,
nameInLocale, MAX_CHAR_SET_STRING_LENGTH+1);
if ( x == 0 )
return 0;
return nameInLocale;
}
void Param::setUTF16StrLit (NAWchar *utf16Str)
{
if (utf16StrLit_)
delete [] utf16StrLit_;
utf16StrLit_ = new NAWchar [NAWstrlen(utf16Str) + 1];
NAWstrcpy(utf16StrLit_, utf16Str);
}
void NAWriteConsole(const NAWchar *str, ostream& outStream,
NABoolean newline,
NABoolean comment,
CharInfo::CharSet terminal_cs)
{
if (!str) return;
char mbstr[DEST_BUF_SIZE + 16];
#pragma nowarn(1506) // warning elimination
UnicodeStringToLocale(terminal_cs, str, NAWstrlen(str), mbstr, DEST_BUF_SIZE+16);
#pragma warn(1506) // warning elimination
NAWriteConsole(mbstr, outStream, newline, comment);
}
Int32 ComAnsiNameToUTF8 ( const NAWchar * inAnsiNameInUCS2 // in - valid ANSI SQL name in UCS2
, char * outBuf4AnsiNameInMBCS // out - out buffer
, const Int32 outBufSizeInBytes // in - out buffer max len in bytes
)
{
if (outBuf4AnsiNameInMBCS == NULL || outBufSizeInBytes <= 0)
return -2; // CNV_ERR_BUFFER_OVERRUN - No output buffer or not big enough
if (inAnsiNameInUCS2 == NULL)
return -3; // CNV_ERR_NOINPUT - No input buffer or input cnt <= 0
else if (NAWstrlen(inAnsiNameInUCS2) == 0)
{
outBuf4AnsiNameInMBCS[0] = 0;
return 0; // success
}
const Int32 inAnsiNameInBytes = NAWstrlen(inAnsiNameInUCS2) * BYTES_PER_NAWCHAR;
Int32 ansiNameCharSet = (Int32)ComGetNameInterfaceCharSet();
Int32 convAnsiNameCS = (Int32)/*cnv_charset*/convertCharsetEnum (ansiNameCharSet);
char * pFirstByteOfTheUntranslatedChar = NULL;
UInt32 iOutStrLenInBytesIncludingNull = 0;
UInt32 iNumTranslatedChars = 0;
Int32 iConvErrorCode = UTF16ToLocale
( cnv_version1 // in - const enum cnv_version
, (const char *) inAnsiNameInUCS2 // in - const char * in_bufr
, (Int32) inAnsiNameInBytes // in - const Int32 in_len_in_bytes
, (const char *) outBuf4AnsiNameInMBCS // in/out - const char * out_bufr
, (Int32) outBufSizeInBytes // in - const Int32 out_bufr_max_len_in bytes
, (cnv_charset) convAnsiNameCS // in - enum cnv_charset conv_charset
, pFirstByteOfTheUntranslatedChar // out - char * & first_untranslated_char
, &iOutStrLenInBytesIncludingNull // out - UInt32 * output_data_len_p
, 0 // in - const Int32 conv_flags
, (Int32) TRUE // in - const Int32 add_null_at_end_Flag
, (Int32) FALSE // in - const int32 allow_invalids
, &iNumTranslatedChars // out - UInt32 * translated_char_cnt_p
, (const char *) NULL /* i.e. "?" */ // in - const char * substitution_char = NULL
);
return iConvErrorCode;
}
void Param::setValue_(const NAWchar * value_, CharInfo::CharSet x_)
{
if (x_ == CharInfo::UNICODE && converted_value) {
delete [] converted_value;
converted_value = 0;
};
cs = x_;
NAWchar* wvalue = new NAWchar[NAWstrlen(value_) + 1];
NAWstrcpy(wvalue, value_);
value = (char*) wvalue;
inSingleByteForm_ = FALSE;
}
// Changes to this function should be emulated in HandleCLIError (SqlCmd.C)
void NADumpDiags(ostream& outStream, ComDiagsArea* diags,
NABoolean newline,
Int32 commentIf,
FILE* fp,
short verbose,
CharInfo::CharSet terminal_cs)
{
if (!diags) return;
Int32 numDiags = diags->getNumber();
if (!numDiags) return;
Int32 numWarns = diags->getNumber(DgSqlCode::WARNING_);
if ( commentIf != NO_COMMENT )
outStream << endl; // blank line at beginning
if (fp) fprintf(fp, "\n");
NABoolean sqlcodePrefixAdded = (commentIf != NO_COMMENT);
for (Int32 i = 0; i++ < numDiags; )
{
NABoolean cmt = sqlcodePrefixAdded && commentIf &&
(commentIf < 0 || (*diags)[i].getSQLCODE() >= 0);
if ( verbose || (!verbose) && (*diags)[i].getSQLCODE() <= 0 )
{
const NAWchar *msg = (*diags)[i].getMessageText(sqlcodePrefixAdded); // NAWchar, not TCHAR
NAWriteConsole(msg, outStream, newline, cmt, terminal_cs);
if (fp) // if a logfile is open, mirror messages to it
{
char mbstr[DEST_BUF_SIZE + 16];
#pragma nowarn(1506) // warning elimination
UnicodeStringToLocale(terminal_cs, msg, NAWstrlen(msg),
mbstr, DEST_BUF_SIZE);
#pragma warn(1506) // warning elimination
FixCarriageReturn(mbstr);
fprintf(fp, "%s\n", mbstr);
if (newline) fprintf(fp, "\n");
}
}
}
outStream << flush;
if (fp) fflush(fp);
}
void FixCarriageReturn(NAWchar *str)
{
// remove any trailing \r(carriage return) or \n(line feed) from error text.
size_t len = NAWstrlen(str);
if (len > 0 && str[len-1] == '\n')
len--;
if (len > 0 && str[len-1] == '\r')
len--;
size_t j = 0;
for (size_t i = 0; i < len; i++)
{
if (str[i] != '\r')
{
str[j] = str[i];
j++;
}
}
str[j] = '\0';
}
char* Param::getDisplayValue(CharInfo::CharSet display_cs)
{
if ( isInSingleByteForm() == FALSE && getCharSet() == CharInfo::UNICODE ) {
if ( display_value == NULL )
{
NAWchar* wvalue = (NAWchar*)value;
Lng32 wlen = (Lng32)NAWstrlen(wvalue);
display_value = new char[wlen+1];
UnicodeStringToLocale(display_cs, wvalue, wlen,
display_value, wlen+1,
TRUE, // add null at end
TRUE // non-convertable char to ?
);
}
return display_value;
} else
return getValue();
}
void ErrorMessage::insertParams(NAError * errcb)
{
if (errcb->getErrParamCount() > 0)
{
// Note that we allocate twice the size for tmp, in order to forestall
// array overrun problems (i.e. memory corruption)
NAWchar tmp[MSG_BUF_SIZE * 2];
NAWchar paramName[MSG_BUF_SIZE];
NAWchar paramVal[MSG_BUF_SIZE]; // regular char, not TCHAR
Int32 paramLen;
Lng32 paramPos;
Int32 tmpLen = 0;
Int32 truncation = FALSE;
#pragma nowarn(1506) // warning elimination
Int32 msgBufOrigLen = NAWstrlen(msgBuf_);
#pragma warn(1506) // warning elimination
for (Int32 i = 0; i < msgBufOrigLen; i++)
{
if (msgBuf_[i] == ERRORPARAM_BEGINMARK)
{
// Get the formal parameter name, excluding the leading '$' mark
NAWchar *p = paramName;
while (++i < msgBufOrigLen &&
(isalnum(msgBuf_[i]) || msgBuf_[i] == ERRORPARAM_TYPESEP))
*p++ = msgBuf_[i];
*p = NAWchar('\0');
i--; // let's not lose a character!
paramPos = FixupMessageParam(paramName, POSITIONAL_PARAM);
if (paramPos >= 0)
{
paramVal[0] = NAWchar('\0'); // default is empty param
NAErrorParam * param = errcb->getNAErrorParam(paramPos);
if (param)
switch (param->getNAErrorParamType())
{
case NAErrorParam::NAERROR_PARAM_TYPE_INTEGER:
NAWsprintf(paramVal,WIDE_("%d"),param->getIntegerNAErrorParam());
break;
case NAErrorParam::NAERROR_PARAM_TYPE_CHAR_STRING:
NAWsprintf(paramVal,WIDE_("%s"),param->getStringNAErrorParam());
break;
}
#pragma nowarn(1506) // warning elimination
paramLen = NAWstrlen(paramVal);
#pragma warn(1506) // warning elimination
NAWstrncpy(&tmp[tmpLen], paramVal, paramLen);
}
else // invalid formal param (e.g. "$ab" "$9~" "$~9" "$9x")
{
tmp[tmpLen++] = ERRORPARAM_BEGINMARK;
#pragma nowarn(1506) // warning elimination
paramLen = NAWstrlen(paramName);
#pragma warn(1506) // warning elimination
NAWstrncpy(&tmp[tmpLen], paramName, paramLen);
}
tmpLen += paramLen;
}
else
{
tmp[tmpLen++] = msgBuf_[i];
}
// If necessary, truncate the message and exit loop early.
// The -1 is for the terminating '\0' below the loop.
if (tmpLen > MSG_BUF_SIZE - 1)
{
tmpLen = MSG_BUF_SIZE - 1;
truncation = TRUE;
break;
}
} // for
// Indicate truncation by overwriting last three characters with '...'
if (truncation)
tmp[tmpLen-3] = tmp[tmpLen-2] = tmp[tmpLen-1] = NAWchar('.');
NAWstrncpy(msgBuf_, tmp, tmpLen);
msgBuf_[tmpLen] = NAWchar('\0');
}
} // ErrorMessage::insertParams()
void ErrorMessage::printErrorMessage(NAError * errcb)
{
NAWchar* tmp = msgBuf_;
// This is always a positive number (but make sure of it!)
NAErrorCode erc_abs = errcb->getErrCode();
if (erc_abs < 0) erc_abs = -erc_abs;
// A warning is positive, an error negative --
// GetErrorMessage generates the proper text for each.
NAErrorCode erc_signed = (errcb->getErrType() == NAError::NAERROR_WARNING) ?
erc_abs : -erc_abs;
NABoolean msgNotFound = GetErrorMessage(erc_signed, tmp);
NABoolean forceParamSubst = msgNotFound && errcb->getErrParamCount() > 0;
/*
// if tmp was assigned to a different (e.g. a static) string, we need to copy
// its contents into this msgBuf_ so that insertParams overwrites our copy
// and not the original.
*/
NAWstrcpy(msgBuf_, tmp);
if (forceParamSubst)
{
// msgBuf_ will contain a suitable msg-not-found message, so now we just
// append substitution parameters to at least make debugging easier.
//
// This mirrors what ComCondition::getMessageText does.
NAWstrcat(msgBuf_, WIDE_(" $0 $1 $2 $3 $4 $5 $6 $7 $8 $9"));
//dbg: NAWstrcat(msgBuf_, WIDE_(" $ $$ $ab $9 $~ $~~ $~0 $0~ $~a $a~ $0x $0x~int0 $int0~x # $0~int0 $int0~0 $0 $00 $0$0"));
//dbg: NAWstrcat(msgBuf_, WIDE_(" $Int0~0$int0~1 $0~Int0$1~int0 #"));
//dbg: NAWstrcat(msgBuf_, WIDE_(" $Int0~0$int0~0 $0~Int0$0~int0 #"));
//dbg: NAWstrcat(msgBuf_, WIDE_(" $Int0~0$0~int0 $0~Int0$int0~0 #"));
}
ErrorMessageOverflowCheckW(msgBuf_, MSG_BUF_SIZE);
insertParams(errcb);
if (forceParamSubst)
{
// remove trailing blanks and unsubstituted substitution marks
#pragma nowarn(1506) // warning elimination
Int32 tmpLen = NAWstrlen(msgBuf_);
#pragma warn(1506) // warning elimination
while (--tmpLen >= 0 &&
(msgBuf_[tmpLen] == NAWchar(' ') ||
msgBuf_[tmpLen] == NAWchar('\t') ||
msgBuf_[tmpLen] == ERRORPARAM_BEGINMARK))
;
msgBuf_[++tmpLen] = NAWchar('\0');
}
char msgBuf8bit[2*MSG_BUF_SIZE];
UnicodeStringToLocale(CharInfo::ISO88591, msgBuf_, MSG_BUF_SIZE, msgBuf8bit, 2*MSG_BUF_SIZE);
printf("%s\n", msgBuf8bit);
fflush(stdout);
} // ErrorMessage::printErrorMessage()
void ReadTableDef::displayTreeMX(const desc_struct * top,
const char * caller) const
{
if (top == NULL) return;
char title[50];
snprintf(title, sizeof(title),
", type %d, address %p, parent %s\n",
top->NODETYPE_MX, (void *)top, caller);
#undef TITLE
#define TITLE(XXX) cout << "### " << XXX << title; \
strcpy(title, XXX)
cout.setf(ios::right);
switch (top->NODETYPE_MX)
{
case TYPEMX(CHECK_CONSTRNTS):
{
TITLE("CHECK_CONSTRNTS");
CASTMX(check_constrnts);
COUT(check_constrnts, seqnumber);
COUT_STRING(check_constrnts, constrnt_text);
}
break;
case TYPEMX(COLUMNS):
{
TITLE("COLUMNS");
CASTMX(columns);
COUT(columns, tablename);
COUT(columns, colname);
COUT(columns, colnumber);
COUT(columns, datatype);
COUT(columns, length);
COUT(columns, scale);
COUT(columns, precision);
COUT_ENUM(columns, datetimestart);
COUT_ENUM(columns, datetimeend);
COUT(columns, datetimefractprec);
COUT(columns, intervalleadingprec);
COUT(columns, offset);
COUT(columns, null_flag);
COUT(columns, upshift);
COUT(columns, colclass);
COUT(columns, uec);
COUT_STRING(columns, highval);
COUT_STRING(columns, lowval);
Int32 defaultValueInLocaleLen =
#pragma nowarn(1506) // warning elimination
NAWstrlen((NAWchar*)(columns->defaultvalue));
#pragma warn(1506) // warning elimination
char* defaultValueInLocale = new HEAP char[defaultValueInLocaleLen+1];
CharInfo::CharSet mapCharSet = SqlParser_ISO_MAPPING;
Int32 x = UnicodeStringToLocale(mapCharSet,
(NAWchar*)(columns->defaultvalue), defaultValueInLocaleLen,
defaultValueInLocale, defaultValueInLocaleLen+1
);
if (columns->defaultvalue) {
cout << " " << setw(20) << "defaultvalue"
<< " " << defaultValueInLocale << endl;
} else {
cout << " " << setw(20) << "defaultvalue" << " is null" << endl;
}
NADELETEBASIC(defaultValueInLocale, HEAP);
}
break;
case TYPEMX(CONSTRNTS):
{
TITLE("CONSTRNTS");
CASTMX(constrnts);
COUT(constrnts, constrntname);
COUT(constrnts, tablename);
COUT_ENUM(constrnts, type);
COUT(constrnts, colcount);
COUT_STRING(constrnts, indexname);
displayTreeMX(constrnts->check_constrnts_desc, title);
displayTreeMX(constrnts->constr_key_cols_desc, title);
displayTreeMX(constrnts->referenced_constrnts_desc, title);
displayTreeMX(constrnts->referencing_constrnts_desc, title);
}
break;
case TYPEMX(CONSTRNT_KEY_COLS):
{
TITLE("CONSTRNT_KEY_COLS");
CASTMX(constrnt_key_cols);
COUT(constrnt_key_cols, colname);
COUT(constrnt_key_cols, position);
}
break;
case TYPEMX(FILES):
{
TITLE("FILES");
CASTMX(files);
COUT_ENUM(files, fileorganization);
COUT(files, audit);
COUT(files, auditcompress);
COUT(files, compressed);
displayTreeMX(files->partns_desc, title);
}
break;
case TYPEMX(HISTOGRAM):
{
TITLE("HISTOGRAM");
CASTMX(histogram);
COUT(histogram, tablename);
COUT(histogram, tablecolnumber);
COUT(histogram, histid);
COUT(histogram, colposition);
COUT(histogram, rowcount);
COUT(histogram, uec);
COUT_STRING(histogram, highval);
COUT_STRING(histogram, lowval);
displayTreeMX(histogram->hist_interval_desc, title);
}
break;
case TYPEMX(HIST_INTERVAL):
{
TITLE("HIST_INTERVAL");
CASTMX(hist_interval);
COUT(hist_interval, histid);
COUT(hist_interval, intnum);
COUT(hist_interval, intboundary);
COUT(hist_interval, rowcount);
COUT(hist_interval, uec);
}
break;
case TYPEMX(INDEXES):
{
TITLE("INDEXES");
CASTMX(indexes);
COUT(indexes, tablename);
COUT(indexes, indexname);
COUT(indexes, keytag);
COUT(indexes, record_length);
COUT(indexes, colcount);
COUT(indexes, unique);
displayTreeMX(indexes->files_desc, title);
displayTreeMX(indexes->keys_desc, title);
displayTreeMX(indexes->non_keys_desc, title);
}
break;
case TYPEMX(KEYS):
{
TITLE("KEYS");
CASTMX(keys);
COUT(keys, indexname);
COUT(keys, keyseqnumber);
COUT(keys, tablecolnumber);
COUT(keys, ordering);
}
break;
case TYPEMX(PARTNS):
{
TITLE("PARTNS");
CASTMX(partns);
COUT(partns, tablename);
COUT(partns, primarypartition);
COUT(partns, partitionname);
COUT_STRING(partns, firstkey);
}
break;
case TYPEMX(REF_CONSTRNTS):
{
TITLE("REF_CONSTRNTS");
CASTMX(ref_constrnts);
COUT(ref_constrnts, constrntname);
COUT(ref_constrnts, tablename);
}
break;
case TYPEMX(TABLE):
{
TITLE("TABLE");
CASTMX(table);
COUT_LARGEINT(table, createtime);
COUT_LARGEINT(table, redeftime);
COUT(table, tablename);
COUT(table, record_length);
COUT(table, colcount);
COUT(table, constr_count);
COUT(table, rowcount);
displayTreeMX(table->files_desc, title);
displayTreeMX(table->columns_desc, title);
displayTreeMX(table->views_desc, title);
displayTreeMX(table->indexes_desc, title);
displayTreeMX(table->constrnts_desc, title);
if (table->constrnts_tables_desc != top)
displayTreeMX(table->constrnts_tables_desc, title);
displayTreeMX(table->referenced_tables_desc, title);
displayTreeMX(table->referencing_tables_desc, title);
displayTreeMX(table->histograms_desc, title);
}
break;
case TYPEMX(VIEW):
{
TITLE("VIEW");
CASTMX(view);
COUT(view, viewname);
COUT_STRING(view, viewtext);
COUT_STRING(view, viewchecktext);
COUT(view, updatable);
COUT(view, insertable);
}
break;
default:
{
TITLE("??? UNKNOWN ???");
}
break;
} // switch
displayTreeMX (top->header.next, title);
} // displayTreeMX
short Param::convertValue(SqlciEnv * sqlci_env, short targetType,
Lng32 &targetLen,
Lng32 targetPrecision,
Lng32 targetScale,
Lng32 vcIndLen,
ComDiagsArea* diags) {
// get rid of the old converted value
if (converted_value) {
delete [] converted_value;
converted_value = 0;
};
short sourceType;
Lng32 sourceLen;
// set up the source and its length based on the how the value is passed-in.
if ( isInSingleByteForm() == FALSE ) {
sourceLen = (Lng32)(NAWstrlen((NAWchar*)value) * BYTES_PER_NAWCHAR);
switch (getCharSet()) {
case CharInfo::UNICODE:
sourceType = REC_NCHAR_F_UNICODE;
break;
case CharInfo::KANJI_MP:
case CharInfo::KSC5601_MP:
sourceType = REC_BYTE_F_ASCII; // KANJI/KSC passed in as NAWchar*
break;
default:
return SQL_Error; // error case
}
} else {
sourceLen = (Lng32)strlen(value); // for any source in single-byte format
sourceType = REC_BYTE_F_ASCII;
}
char * pParamValue = value;
if ( DFS2REC::isAnyCharacter(targetType) ) {
if (termCS_ == CharInfo::UnknownCharSet)
termCS_ = sqlci_env->getTerminalCharset();
if (cs == CharInfo::UnknownCharSet)
{
isQuotedStrWithoutCharSetPrefix_ = TRUE;
cs = termCS_;
}
// If the target is CHARACTER and param is set as [_cs_prefix]'...', then
// make sure the source is assignment compatible with the target.
CharInfo::CharSet targetCharSet = (CharInfo::CharSet)targetScale;
if ( targetCharSet == CharInfo::UNICODE )
{
if (getUTF16StrLit() == (NAWchar*)NULL)
{
utf16StrLit_ = new NAWchar [ sourceLen * 2 + 1 ]; // plenty of room
Lng32 utf16StrLenInNAWchars =
LocaleStringToUnicode(cs/*sourceCS*/, /*sourceStr*/value, sourceLen,
utf16StrLit_/*outputBuf*/, sourceLen+1/*outputBufSizeInNAWchars*/,
TRUE /* in - NABoolean addNullAtEnd*/);
if (sourceLen > 0 && utf16StrLenInNAWchars == 0)
return SQL_Error;
// ComASSERT(utf16StrLenInNAWchars == NAWstrlen(getUTF16StrLit()));
// Resize the NAWchar buffer to save space
NAWchar *pNAWcharBuf = new NAWchar [ utf16StrLenInNAWchars + 1 ];
NAWstrncpy (pNAWcharBuf, utf16StrLit_, utf16StrLenInNAWchars + 1);
pNAWcharBuf[utf16StrLenInNAWchars] = NAWCHR('\0'); // play it safe
delete [] utf16StrLit_;
utf16StrLit_ = pNAWcharBuf; // do not deallocate pNAWcharBuf
}
sourceLen = (Lng32)(NAWstrlen(getUTF16StrLit()) * BYTES_PER_NAWCHAR);
// check to see if the parameter utf16 string fits in the target
if ( sourceLen > targetLen )
return SQL_Error;
pParamValue = (char *)getUTF16StrLit();
sourceType = REC_NCHAR_F_UNICODE;
}
} else {
// MP NCHAR (KANJI/KSC) can not be converted to non-character objects
if ( CharInfo::is_NCHAR_MP(cs) )
return SQL_Error;
}
switch(targetType) {
case REC_BIN16_SIGNED:
case REC_BIN16_UNSIGNED:
case REC_BPINT_UNSIGNED:
case REC_BIN32_SIGNED:
case REC_BIN32_UNSIGNED:
case REC_BIN64_SIGNED:
case REC_DECIMAL_UNSIGNED:
case REC_DECIMAL_LSE:
case REC_FLOAT32:
case REC_FLOAT64:
case REC_TDM_FLOAT32:
case REC_TDM_FLOAT64:
case REC_BYTE_F_ASCII:
case REC_BYTE_V_ASCII:
case REC_BYTE_V_ASCII_LONG:
case REC_NCHAR_F_UNICODE:
case REC_NCHAR_V_UNICODE:
{
char *VCLen = NULL;
short VCLenSize = 0;
// 5/27/98: added VARNCHAR cases
if ((targetType == REC_BYTE_V_ASCII) ||
(targetType == REC_BYTE_V_ASCII_LONG) ||
(targetType == REC_NCHAR_V_UNICODE))
{
// add bytes for variable length field
VCLenSize = vcIndLen; //sizeof(short);
VCLen = converted_value = new char[targetLen + VCLenSize];
} else
converted_value = new char[targetLen];
#pragma nowarn(1506) // warning elimination
ex_expr::exp_return_type ok;
CharInfo::CharSet TCS = sqlci_env->getTerminalCharset();
CharInfo::CharSet ISOMAPCS = sqlci_env->getIsoMappingCharset();
NAString* tempstr;
if (
DFS2REC::isAnyCharacter(sourceType) && DFS2REC::isAnyCharacter(targetType) &&
!(getUTF16StrLit() != NULL && sourceType == REC_NCHAR_F_UNICODE && targetScale == CharInfo::UCS2) &&
/*source*/cs != targetScale/*i.e., targetCharSet*/
)
{
charBuf cbuf((unsigned char*)pParamValue, sourceLen);
NAWcharBuf* wcbuf = 0;
Int32 errorcode = 0;
wcbuf = csetToUnicode(cbuf, 0, wcbuf,
cs/*sourceCharSet*/
, errorcode);
if (errorcode != 0) return SQL_Error;
tempstr = unicodeToChar(wcbuf->data(),wcbuf->getStrLen(),
targetScale/*i.e., targetCharSet*/
);
if (tempstr == NULL)
return SQL_Error; //Avoid NULL ptr reference if conversion error
sourceType = targetType; // we just converted it to the target type
sourceLen = tempstr->length();
pParamValue = (char *)tempstr->data();
if ( sourceLen > targetLen )
return SQL_Error;
}
ok = convDoIt(pParamValue,
sourceLen,
sourceType,
0, // source Precision
targetScale, // new charset we converted to
&converted_value[VCLenSize],
targetLen,
targetType,
targetPrecision,
targetScale,
VCLen,
VCLenSize,
0,
&diags);
if ( ok != ex_expr::EXPR_OK)
{
// No need to delete allocated memory before return because class member
// converted_value still points to allocated memory that is deleted in
// desctructor.
return SQL_Error; // error case
}
#pragma warn(1506) // warning elimination
};
break;
case REC_DATETIME: {
char *VCLen = NULL;
short VCLenSize = 0;
converted_value = new char[targetLen + 1];
#pragma nowarn(1506) // warning elimination
ex_expr::exp_return_type ok = convDoIt(value,
sourceLen,
sourceType,
0, // source Precision
0, // source Scale
converted_value,
targetLen,
targetType,
targetPrecision,
targetScale,
VCLen,
VCLenSize,
0,
&diags);
if ( ok != ex_expr::EXPR_OK)
{
return SQL_Error; // error case
}
#pragma warn(1506) // warning elimination
};
break;
case REC_INT_YEAR:
case REC_INT_MONTH:
case REC_INT_YEAR_MONTH:
case REC_INT_DAY:
case REC_INT_HOUR:
case REC_INT_DAY_HOUR:
case REC_INT_MINUTE:
case REC_INT_HOUR_MINUTE:
case REC_INT_DAY_MINUTE:
case REC_INT_SECOND:
case REC_INT_MINUTE_SECOND:
case REC_INT_HOUR_SECOND:
case REC_INT_DAY_SECOND: {
// convert target back to string.
converted_value = new char[targetLen];
Lng32 convFlags = CONV_ALLOW_SIGN_IN_INTERVAL;
#pragma nowarn(1506) // warning elimination
short ok =
convDoItMxcs(value,
sourceLen,
sourceType,
0, // source Precision
0, // source Scale
converted_value,
targetLen,
targetType,
targetPrecision,
targetScale,
convFlags);
if ( ok != 0 )
{
// No need to delete allocated memory before return because class member
// converted_value still points to allocated memory that is deleted in
// desctructor.
return SQL_Error; // error case
}
#pragma warn(1506) // warning elimination
};
break;
case REC_NUM_BIG_UNSIGNED:
case REC_NUM_BIG_SIGNED:
{
converted_value = new char[targetLen];
#pragma nowarn(1506) // warning elimination
short ok =
convDoItMxcs(value,
sourceLen,
sourceType,
0, // source Precision
0, // source Scale
converted_value,
targetLen,
targetType,
targetPrecision,
targetScale,
0);
if ( ok != 0 )
{
// No need to delete allocated memory before return because class member
// converted_value still points to allocated memory that is deleted in
// desctructor.
return SQL_Error; // error case
}
#pragma warn(1506) // warning elimination
};
break;
default:
break;
};
return 0;
}
