//////////////////////////////////////////// // 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; }