void dumpLmParameter(LmParameter &p, Lng32 i, const char *prefix)
{
if (prefix == NULL)
prefix = "";
ServerDebug("%s [%ld] Name [%s]", prefix, i,
p.getParamName() ? p.getParamName() : "");
ServerDebug("%s FS type %s, prec %d, scale %d, charset %d", prefix,
getDatatypeAsString(p.fsType()),
(Int32) p.prec(), (Int32) p.scale(), (Int32) p.encodingCharSet());
ServerDebug("%s direction %s, collation %d, objMap %ld, resultSet %s",
prefix,
getDirectionName(p.direction()), (Int32) p.collation(),
(Int32) p.objMapping(), TF_STRING(p.resultSet()));
ServerDebug("%s IN offset %d, len %d, null offset %d, null len %d",
prefix, (Int32) p.inDataOffset(), (Int32) p.inSize(),
(Int32) p.inNullIndOffset(), (Int32) p.inNullIndSize());
ServerDebug("%s vclen offset %d, vclen len %d", prefix,
(Int32) p.inVCLenIndOffset(), (Int32) p.inVCLenIndSize());
ServerDebug("%s OUT offset %d, len %d, null offset %d, null len %d",
prefix, (Int32) p.outDataOffset(), (Int32) p.outSize(),
(Int32) p.outNullIndOffset(), (Int32) p.outNullIndSize());
ServerDebug("%s vclen offset %d, vclen len %d", prefix,
(Int32) p.outVCLenIndOffset(), (Int32) p.outVCLenIndSize());
} // dumpLmParameter
void Domain::getDatatypeParts(wxString& type, wxString& size, wxString& scale)
{
size = scale = wxEmptyString;
wxString datatype = getDatatypeAsString();
wxString::size_type p1 = datatype.find("(");
if (p1 != wxString::npos)
{
type = datatype.substr(0, p1);
wxString::size_type p2 = datatype.find(",");
if (p2 == wxString::npos)
p2 = datatype.find(")");
else
{
wxString::size_type p3 = datatype.find(")");
scale = datatype.substr(p2 + 1, p3 - p2 - 1);
}
size = datatype.substr(p1 + 1, p2 - p1 - 1);
}
else
{
type = datatype;
// HACK ALERT: some better fix needed, but we don't want the subtype
if (datatypeM == 261)
type = SqlTokenizer::getKeyword(kwBLOB);
}
}
void Attributes::displayContents(Space * space, Int32 operandNum,
char * constsArea, Attributes * spAttr)
{
#ifndef __EID
char buf[250];
char r[15];
if (operandNum == 0)
str_cpy(r, " (result)",str_len(" (result)")+1,'\0');
else
r[0] = 0;
str_sprintf(buf, " Operand #%d%s:", operandNum, r);
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
str_sprintf(buf, " Datatype = %s(%d), Length = %d, Null Flag = %d",
getDatatypeAsString(getDatatype()), getDatatype(), getLength(), getNullFlag());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
if ((getDatatype() == REC_BLOB) ||
(getDatatype() == REC_CLOB))
{
Int16 precision = getPrecision();
UInt16 scale = getScaleAsUI();
Lng32 lobLen = (precision << 16);
lobLen += scale;
Int64 ll = (Int64)lobLen;
// Int64 ll = (Int64)getPrecision() * 1000 + (Int64)getScale();
str_sprintf(buf, " LobLength = %Ld Mb", ll);
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}
str_sprintf(buf, " Precision = %d, Scale = %d, Collation = %d, flags_ = %b",
getPrecision(), getScale(), getCollation(), flags_);
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
str_cpy(buf, " Tuple Data Format = ",
str_len(" Tuple Data Format = ")+1,'\0');
switch (getTupleFormat())
{
case ExpTupleDesc::UNINITIALIZED_FORMAT:
str_cat(buf, "UNINITIALIZED_FORMAT", buf);
break;
case ExpTupleDesc::PACKED_FORMAT:
str_cat(buf, "PACKED_FORMAT", buf);
break;
case ExpTupleDesc::SQLMX_KEY_FORMAT:
str_cat(buf, "SQLMX_KEY_FORMAT", buf);
break;
case ExpTupleDesc::SQLARK_EXPLODED_FORMAT:
str_cat(buf, "SQLARK_EXPLODED_FORMAT", buf);
break;
case ExpTupleDesc::SQLMX_FORMAT:
str_cat(buf, "SQLMX_FORMAT", buf);
break;
case ExpTupleDesc::SQLMX_ALIGNED_FORMAT:
str_cat(buf, "SQLMX_ALIGNED_FORMAT", buf);
break;
default:
str_cat(buf, "Unrecognized format", buf);
break;
} // switch tuple format
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
if (isSpecialField())
{
str_sprintf(buf, " DefaultFieldNum = %d",getDefaultFieldNum());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}
char constOrTemp[150];
if ((getAtp()) == 0 && (getAtpIndex() == 0))
{
str_cpy(constOrTemp, " (Constant)",
str_len(" (Constant)")+1,'\0');
}
else if ((getAtp() == 0) && (getAtpIndex() == 1))
str_cpy(constOrTemp, " (Temporary)",
str_len(" (Temporary)")+1,'\0');
else if ((getAtp() == 1) && (getAtpIndex() == 1))
str_cpy(constOrTemp, " (Persistent)",
str_len(" (Persistent)")+1,'\0');
else if (getAtpIndex() == 0)
str_cpy(constOrTemp, " !!!ERROR!!! - Invalid (Atp,AtpIndex)",
str_len(" !!!ERROR!!! - Invalid (Atp,AtpIndex)")+1,'\0');
else
str_cpy(constOrTemp, " ", str_len(" ")+1,'\0');
str_sprintf(buf, " Atp = %d, AtpIndex = %d%s",
getAtp(), getAtpIndex(), constOrTemp);
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
str_sprintf(buf, " Offset = %d, NullIndOffset = %d, VClenIndOffset = %d",
(getOffset() == ExpOffsetMax ? -1 : (Lng32)getOffset()),
(getNullIndOffset() == ExpOffsetMax ? -1 : getNullIndOffset()),
(getVCLenIndOffset() == ExpOffsetMax ? -1 : getVCLenIndOffset()));
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
if ((getTupleFormat() == ExpTupleDesc::SQLMX_FORMAT) ||
(getTupleFormat() == ExpTupleDesc::SQLMX_ALIGNED_FORMAT))
{
str_sprintf(buf, " RelOffset = %d, VoaOffset = %d, NullBitIdx = %d",
getRelOffset(),
(getVoaOffset() == ExpOffsetMax ? -1 : getVoaOffset()),
getNullBitIndex());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}
str_sprintf(buf, " NullIndLength = %d, VClenIndLength = %d",
getNullIndicatorLength(), getVCIndicatorLength());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
if ((getRowsetSize() > 0) ||
(getRowsetInfo()))
{
str_sprintf(buf, " rowsetSize_ = %d, rowsetInfo_ = %b",
getRowsetSize(), getRowsetInfo());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}
if (spAttr)
{
str_sprintf(buf, " ValueId = %d",
((ShowplanAttributes *)spAttr)->valueId());
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
str_sprintf(buf, " Text = %s",
(((ShowplanAttributes *)spAttr)->text() ?
((ShowplanAttributes *)spAttr)->text() : ""));
space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short));
}
#endif // __EID
}
//Detailed error support for conversions, especially for use in convdoit.
ComDiagsArea *ExRaiseDetailSqlError(CollHeap* heap,
ComDiagsArea** diagsArea,
ExeErrorCode err,
char *src,
Int32 srcLength,
Int16 srcType,
Int32 srcScale,
Int16 tgtType,
UInt32 flags,
Int32 tgtLength,
Int32 tgtScale,
Int32 tgtPrecision,
Int32 srcPrecision)
{
//if looping situation, no need to proceed further, return back.
if(flags & CONV_CONTROL_LOOPING)
return NULL;
NABoolean intermediate;
if( flags & CONV_INTERMEDIATE_CONVERSION )
intermediate = TRUE;
else
intermediate = FALSE;
if (diagsArea == NULL)
return NULL;
if (*diagsArea == NULL){
if (heap == NULL)
return NULL;
*diagsArea = ComDiagsArea::allocate(heap);
}
//Allocate buf once, for formatting and opstring[1].
// |--------formatting--------|--opstring[1]------|
char *buf = new (heap) char[FORMATTING+ OPVALUE_LEN] ;
if( !buf ){
ExRaiseSqlError(heap, diagsArea, err);
return *diagsArea;
}
char *opString = &buf[FORMATTING];
ExConvertErrorToString(heap,
diagsArea,
src,
srcLength,
srcType,
srcScale,
opString,
OPVALUE_LEN);
char srcDatatypeDetail[200];
char tgtDatatypeDetail[200];
char srcTypeAsText[1000];
char tgtTypeAsText[100];
srcTypeAsText[0] = 0;
tgtTypeAsText[0] = 0;
if (srcPrecision != -1)
{
rec_datetime_field startField;
rec_datetime_field endField;
ExpDatetime::getDatetimeFields(srcPrecision, startField, endField);
convertTypeToText_basic(srcTypeAsText,
srcType, srcLength, srcPrecision, srcScale,
startField, endField, 0, 0, 0, 0,
(CharInfo::CharSet)srcScale,
NULL, NULL, 0);
strcpy(srcDatatypeDetail, getDatatypeAsString(srcType, false));
}
else if ((DFS2REC::isCharacterString(srcType)) &&
(srcLength >= 0) &&
(srcScale > 0) &&
(srcPrecision == -1))
str_sprintf(srcDatatypeDetail, "%s,%d BYTES,%s",
getDatatypeAsString(srcType, false),
srcLength,
(srcScale == CharInfo::ISO88591 ? "ISO88591" : "UTF8"));
else
strcpy(srcDatatypeDetail, getDatatypeAsString(srcType, false));
if (tgtLength != -1)
{
rec_datetime_field startField;
rec_datetime_field endField;
ExpDatetime::getDatetimeFields(tgtPrecision, startField, endField);
convertTypeToText_basic(tgtTypeAsText,
tgtType, tgtLength, tgtPrecision, tgtScale,
startField, endField, 0, 0, 0, 0,
(CharInfo::CharSet)tgtScale,
NULL, NULL, 0);
strcpy(tgtDatatypeDetail, getDatatypeAsString(tgtType, false));
}
else if ((DFS2REC::isCharacterString(tgtType)) &&
(tgtLength >= 0) &&
(tgtScale > 0))
str_sprintf(tgtDatatypeDetail, "%s,%d %s,%s",
getDatatypeAsString(tgtType, false),
tgtPrecision ? tgtPrecision : tgtLength,
tgtPrecision ? "CHARS" : "BYTES",
(tgtScale == CharInfo::ISO88591 ? "ISO88591" : "UTF8"));
else
strcpy(tgtDatatypeDetail, getDatatypeAsString(tgtType, false));
str_sprintf(buf,
" %s of Source Type:%s(%s) Source Value:%s to Target Type:%s(%s).",
intermediate? "Intermediate conversion" : "Conversion",
(strlen(srcTypeAsText) == 0 ? getDatatypeAsString(srcType,true) :
srcTypeAsText),
srcDatatypeDetail,
opString,
(strlen(tgtTypeAsText) == 0 ? getDatatypeAsString(tgtType,true) :
tgtTypeAsText),
tgtDatatypeDetail);
**diagsArea << DgSqlCode(-err);
**diagsArea<<DgString0(buf);
NADELETEBASICARRAY(buf, (heap));
return *diagsArea;
}
//Detailed error support for clause expression evaluation.
ComDiagsArea *ExRaiseDetailSqlError(CollHeap* heap,
ComDiagsArea** diagsArea,
ExeErrorCode err,
ex_clause *clause,
char *op_data[])
{
if (diagsArea == NULL)
return NULL;
if (*diagsArea == NULL){
if (heap == NULL)
return NULL;
*diagsArea = ComDiagsArea::allocate(heap);
}
Int16 numOperands = clause->getNumOperands();
Attributes *op;
Int16 i;
// Single allocation of buf is split up to be used for opstrings,
// formatting. See defines at beginning of this header file
// for details.
char *buf = new (heap)
char[(numOperands * (VALUE_TYPE_LEN + OPVALUE_LEN)) + INSTR_LEN + FORMATTING];
if( !buf ){
ExRaiseSqlError(heap, diagsArea, err);
return *diagsArea;
}
char *opStrings = &buf[(numOperands * VALUE_TYPE_LEN) + INSTR_LEN ];
// assign FORMATTING part of address.
char *buf1 = &buf[(numOperands * (VALUE_TYPE_LEN + OPVALUE_LEN)) + INSTR_LEN];
for (i = 1; i < numOperands; i++){
op = clause->getOperand(i);
ExConvertErrorToString(heap,
diagsArea,
(char*)op_data[i],
op->getLength(),
op->getDatatype(),
op->getScale(),
(char*)&opStrings[(i-1)*OPVALUE_LEN],
OPVALUE_LEN);
}
//initialize buf before entering the loop.
buf[0] = '\0';
for(i = 1; i< numOperands; i++){
op = clause->getOperand(i);
str_sprintf(buf1, " Operand%d Type:%s(%s) Operand%d Value:%s",i,
getDatatypeAsString(op->getDatatype(), true),
getDatatypeAsString(op->getDatatype(), false),
i,
&opStrings[(i-1)*OPVALUE_LEN]);
str_cat(buf, buf1, buf);
}
if(numOperands)
{
str_sprintf(buf1,".");
str_cat(buf, buf1, buf);
}
str_sprintf(buf1, " Clause Type:%d Clause number:%d Operation:%s.",
clause->getType(), clause->clauseNum(),
exClauseGetText(clause->getOperType()));
str_cat(buf, buf1, buf);
**diagsArea << DgSqlCode(-err);
**diagsArea<<DgString0(buf);
NADELETEBASICARRAY(buf, (heap));
return *diagsArea;
}
//Detailed error support for pcode expression evaluation.
ComDiagsArea *ExRaiseDetailSqlError(CollHeap* heap,
ComDiagsArea** diagsArea,
ExeErrorCode err,
Int32 pciInst,
char *op1,
char *op2,
char *op3)
{
if (diagsArea == NULL)
return NULL;
if (*diagsArea == NULL){
if (heap == NULL)
return NULL;
*diagsArea = ComDiagsArea::allocate(heap);
}
PCIT::Operation operation;
PCIT::AddressingMode am[6];
Int32 numAModes;
Int32 rangeInst = PCode::isInstructionRangeType((PCIT::Instruction)pciInst)? 1: 0;
if(PCode::getOpCodeMapElements( pciInst, operation, am, numAModes ) ){
ExRaiseSqlError(heap, diagsArea, err);
return *diagsArea;
}
// Single allocation of buf is split up to be used for opstrings,
// formatting. See defines at beginning of this header file
// for details.
char *buf = new (heap)
char[(numAModes * (VALUE_TYPE_LEN + OPVALUE_LEN)) + INSTR_LEN + FORMATTING];
if( !buf ){
ExRaiseSqlError(heap, diagsArea, err);
return *diagsArea;
}
char *opStrings = &buf[(numAModes * VALUE_TYPE_LEN) + INSTR_LEN ];
char *buf1 = // assign FORMATTING part of address.
&buf[(numAModes * (VALUE_TYPE_LEN + OPVALUE_LEN)) + INSTR_LEN];
switch( numAModes ){
case 1:
ExConvertErrorToString(heap,
diagsArea,
op1,
PCIT::getOperandLengthForAddressingMode(am[0]),
PCIT::getDataTypeForMemoryAddressingMode(am[0]),
0,
(char*)&opStrings[0],
OPVALUE_LEN);
//construct a formated string and assign to diags area
**diagsArea << DgSqlCode(-err);
if(rangeInst){
str_sprintf( buf, " Source Value:%s not within limits of Target Type:%s(%s).",
&opStrings[0],
getDatatypeAsString(PCIT::getDataTypeForMemoryAddressingMode(am[0]),true),
PCIT::addressingModeString(am[0]));
}
else{
str_sprintf( buf, " Operand Type:%s(%s) Operand Value:%s.",
getDatatypeAsString(PCIT::getDataTypeForMemoryAddressingMode(am[0]),true),
PCIT::addressingModeString(am[0]), &opStrings[0]);
}
str_sprintf( buf1, " Instruction:%s Operation:%s.",
PCIT::instructionString((PCIT::Instruction)pciInst),
PCIT::operationString(operation));
str_cat(buf, buf1, buf);
**diagsArea<<DgString0(buf);
break;
case 3:
case 4:
//since we are only interested in left and right operands, just overright
//am modes to be processed by case 2 below.
am[0] = am[1];
am[1] = am[2];
//do not break here. Flow down to case 2.
case 2:
ExConvertErrorToString(heap,
diagsArea,
op1,
PCIT::getOperandLengthForAddressingMode(am[0]),
PCIT::getDataTypeForMemoryAddressingMode(am[0]),
0,
(char*)&opStrings[0],
OPVALUE_LEN);
ExConvertErrorToString(heap,
diagsArea,
op2,
PCIT::getOperandLengthForAddressingMode(am[1]),
PCIT::getDataTypeForMemoryAddressingMode(am[1]),
0,
(char*)&opStrings[OPVALUE_LEN],
OPVALUE_LEN);
//construct a formated string and assign to diags area
**diagsArea << DgSqlCode(-err);
str_sprintf( buf, " %s Type:%s(%s) %s Value:%s",
rangeInst? "Source":"Operand1",
getDatatypeAsString(PCIT::getDataTypeForMemoryAddressingMode(am[0]),true),
PCIT::addressingModeString(am[0]),
rangeInst? "Source":"Operand1", &opStrings[0]);
str_sprintf( buf1, " %s Type:%s(%s)%s%s Value:%s.",
rangeInst? "Target":"Operand2",
getDatatypeAsString(PCIT::getDataTypeForMemoryAddressingMode(am[1]),true),
PCIT::addressingModeString(am[1]),
rangeInst? (opStrings[OPVALUE_LEN] == '-' ? " Min ": " Max "):" ",
rangeInst? "Target":"Operand2", &opStrings[OPVALUE_LEN]);
str_cat(buf, buf1, buf);
str_sprintf( buf1, " Instruction:%s Operation:%s.",
PCIT::instructionString((PCIT::Instruction)pciInst),
PCIT::operationString(operation));
str_cat(buf, buf1, buf);
**diagsArea<<DgString0(buf);
break;
//Needs to be enhanced for other types. Just dump what ever we have.
default:
ExRaiseSqlError(heap, diagsArea, err);
};
NADELETEBASICARRAY(buf, (heap));
return *diagsArea;
}
