/**
Internal function to test retrieving a SQL_NUMERIC_STRUCT value.
@todo Printing some additional output (sqlnum->val as hex, dec)
@param[in] hstmt Statement handle
@param[in] numstr String to retrieve as SQL_NUMERIC_STRUCT
@param[in] prec Precision to retrieve
@param[in] scale Scale to retrieve
@param[in] sign Expected sign (1=+,0=-)
@param[in] expdata Expected byte array value (need this or expnum)
@param[in] expnum Expected numeric value (if it fits)
@param[in] overflow Whether to expect a retrieval failure (22003)
@return OK/FAIL just like a test.
*/
int sqlnum_test_from_str(SQLHANDLE Stmt,
const char *numstr, SQLCHAR prec, SQLSCHAR scale,
SQLCHAR sign, SQLCHAR *expdata, int expnum,
int overflow)
{
SQL_NUMERIC_STRUCT *sqlnum= malloc(sizeof(SQL_NUMERIC_STRUCT));
SQLCHAR buf[512];
SQLHANDLE ard;
unsigned long numval;
sprintf((char *)buf, "select %s", numstr);
/* OK_SIMPLE_STMT(Stmt, buf); */
CHECK_HANDLE_RC(SQL_HANDLE_STMT, Stmt, SQLExecDirect(Stmt, buf, SQL_NTS));
CHECK_HANDLE_RC(SQL_HANDLE_STMT, Stmt, SQLGetStmtAttr(Stmt, SQL_ATTR_APP_ROW_DESC, &ard, 0, NULL));
CHECK_HANDLE_RC(SQL_HANDLE_DESC, ard, SQLSetDescField(ard, 1, SQL_DESC_TYPE,
(SQLPOINTER) SQL_C_NUMERIC, SQL_IS_INTEGER));
CHECK_HANDLE_RC(SQL_HANDLE_DESC, ard, SQLSetDescField(ard, 1, SQL_DESC_PRECISION,
(SQLPOINTER)(SQLLEN) prec, SQL_IS_INTEGER));
CHECK_HANDLE_RC(SQL_HANDLE_DESC, ard, SQLSetDescField(ard, 1, SQL_DESC_SCALE,
(SQLPOINTER)(SQLLEN) scale, SQL_IS_INTEGER));
CHECK_HANDLE_RC(SQL_HANDLE_DESC, ard, SQLSetDescField(ard, 1, SQL_DESC_DATA_PTR,
sqlnum, SQL_IS_POINTER));
if (overflow)
{
FAIL_IF(SQLFetch(Stmt) != SQL_ERROR, "expected SQL_ERROR");
FAIL_IF(check_sqlstate(Stmt, "22003") != OK, "expected error 22003");
}
else
CHECK_HANDLE_RC(SQL_HANDLE_STMT, Stmt, SQLFetch(Stmt));
is_num(sqlnum->precision, prec);
is_num(sqlnum->scale, scale);
is_num(sqlnum->sign, sign);
if (expdata)
{
IS(!memcmp(sqlnum->val, expdata, SQL_MAX_NUMERIC_LEN));
}
else
{
/* only use this for <=32bit values */
int i;
numval= 0;
for (i= 0; i < 8; ++i)
numval += sqlnum->val[7 - i] << (8 * (7 - i));
if (numval != expnum)
diag("compare %d %d", numval, expnum);
is_num(numval, expnum);
}
CHECK_HANDLE_RC(SQL_HANDLE_STMT, Stmt, SQLFreeStmt(Stmt, SQL_CLOSE));
free(sqlnum);
return OK;
}
/************************************************************************
* name: SQLSetDescFieldW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLSetDescFieldW (SQLHDESC hdesc, SQLSMALLINT record, SQLSMALLINT field,
SQLPOINTER value, SQLINTEGER value_len)
{
//RETCODE ret = ODBC_ERROR;
OutputDebugString ("SQLSetDescFieldW called.\n");
return SQLSetDescField(hdesc, record, field, value, value_len);
}
SQLRETURN SQLSetDescFieldA( SQLHDESC descriptor_handle,
SQLSMALLINT rec_number,
SQLSMALLINT field_identifier,
SQLPOINTER value,
SQLINTEGER buffer_length )
{
return SQLSetDescField( descriptor_handle,
rec_number,
field_identifier,
value,
buffer_length );
}
int
main(int argc, char *argv[])
{
#define TEST_FILE "describecol.in"
const char *in_file = FREETDS_SRCDIR "/" TEST_FILE;
FILE *f;
char buf[256];
SQLINTEGER i;
SQLLEN len;
check_attr_t check_attr_p = check_attr_none;
odbc_connect();
odbc_command("SET TEXTSIZE 4096");
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
f = fopen(in_file, "r");
if (!f)
fopen(TEST_FILE, "r");
if (!f) {
fprintf(stderr, "error opening test file\n");
exit(1);
}
line_num = 0;
while (fgets(buf, sizeof(buf), f)) {
char *p = buf, *cmd;
++line_num;
while (isspace((unsigned char) *p))
++p;
cmd = strtok(p, SEP);
/* skip comments */
if (!cmd || cmd[0] == '#' || cmd[0] == 0 || cmd[0] == '\n')
continue;
if (strcmp(cmd, "odbc") == 0) {
int odbc3 = get_int(strtok(NULL, SEP)) == 3 ? 1 : 0;
if (odbc_use_version3 != odbc3) {
odbc_use_version3 = odbc3;
odbc_disconnect();
odbc_connect();
odbc_command("SET TEXTSIZE 4096");
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
}
}
/* select type */
if (strcmp(cmd, "select") == 0) {
const char *type = strtok(NULL, SEP);
const char *value = strtok(NULL, SEP);
char sql[sizeof(buf) + 40];
SQLMoreResults(odbc_stmt);
odbc_reset_statement();
sprintf(sql, "SELECT CONVERT(%s, %s) AS col", type, value);
/* ignore error, we only need precision of known types */
check_attr_p = check_attr_none;
if (odbc_command_with_result(odbc_stmt, sql) != SQL_SUCCESS) {
odbc_reset_statement();
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
continue;
}
CHKFetch("SI");
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
check_attr_p = check_attr_ird;
}
/* set attribute */
if (strcmp(cmd, "set") == 0) {
const struct attribute *attr = lookup_attr(strtok(NULL, SEP));
char *value = strtok(NULL, SEP);
SQLHDESC desc;
SQLRETURN ret;
SQLINTEGER ind;
if (!value)
fatal("Line %u: value not defined\n", line_num);
/* get ARD */
SQLGetStmtAttr(odbc_stmt, SQL_ATTR_APP_ROW_DESC, &desc, sizeof(desc), &ind);
ret = SQL_ERROR;
switch (attr->type) {
case type_INTEGER:
ret = SQLSetDescField(desc, 1, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLINTEGER));
break;
case type_SMALLINT:
ret = SQLSetDescField(desc, 1, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLSMALLINT));
break;
case type_LEN:
ret = SQLSetDescField(desc, 1, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLLEN));
break;
case type_CHARP:
ret = SQLSetDescField(desc, 1, attr->value, (SQLPOINTER) value, SQL_NTS);
break;
}
if (!SQL_SUCCEEDED(ret))
fatal("Line %u: failure not expected setting ARD attribute\n", line_num);
check_attr_p = check_attr_ard;
}
/* test attribute */
if (strcmp(cmd, "attr") == 0) {
const struct attribute *attr = lookup_attr(strtok(NULL, SEP));
char *expected = strtok(NULL, SEP);
if (!expected)
fatal("Line %u: value not defined\n", line_num);
check_attr_p(attr, expected);
}
}
fclose(f);
odbc_disconnect();
printf("Done.\n");
return g_result;
}
int
main(int argc, char **argv)
{
const struct type *p;
char buf[16];
SQLINTEGER ind;
SQLLEN lind;
SQLHDESC desc;
odbc_connect();
/*
* test setting two time a descriptor
* success all user allocated are ARD or APD so type cheching can be done
* TODO freeing descriptor dissociate it from statements
*/
/* test C types */
for (p = types; p->name; ++p) {
if (SQL_SUCCEEDED
(SQLBindParameter(odbc_stmt, 1, SQL_PARAM_INPUT, p->type, SQL_VARCHAR, (SQLUINTEGER) (-1), 0, buf, 16, &lind))) {
SQLSMALLINT concise_type, type, code;
SQLHDESC desc;
concise_type = type = code = 0;
/* get APD */
SQLGetStmtAttr(odbc_stmt, SQL_ATTR_APP_PARAM_DESC, &desc, sizeof(desc), &ind);
SQLGetDescField(desc, 1, SQL_DESC_TYPE, &type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_CONCISE_TYPE, &concise_type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_DATETIME_INTERVAL_CODE, &code, sizeof(SQLSMALLINT), &ind);
printf("Setted type %s -> [%d (%s), %d (%s), %d]\n",
p->name, (int) concise_type, get_type_name(concise_type), (int) type, get_type_name(type), code);
check_msg(p->flags & FLAG_C, "Type not C successed to be set in APD");
} else {
SQLSMALLINT concise_type, type, code;
SQLHDESC desc;
concise_type = type = code = 0;
fprintf(stderr, "Error setting type %d (%s)\n", (int) p->type, p->name);
concise_type = p->type;
SQLGetStmtAttr(odbc_stmt, SQL_ATTR_APP_PARAM_DESC, &desc, sizeof(desc), &ind);
if (SQL_SUCCEEDED
(SQLSetDescField(desc, 1, SQL_DESC_CONCISE_TYPE, int2ptr(concise_type), sizeof(SQLSMALLINT))))
{
SQLGetDescField(desc, 1, SQL_DESC_TYPE, &type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_CONCISE_TYPE, &concise_type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_DATETIME_INTERVAL_CODE, &code, sizeof(SQLSMALLINT), &ind);
printf("Setted type %s -> [%d (%s), %d (%s), %d]\n",
p->name,
(int) concise_type, get_type_name(concise_type), (int) type, get_type_name(type), code);
check_msg(p->flags & FLAG_C, "Type not C successed to be set in APD");
} else {
check_msg(!(p->flags & FLAG_C), "Type C failed to be set in APD");
}
}
}
printf("\n\n");
/* test SQL types */
SQLGetStmtAttr(odbc_stmt, SQL_ATTR_IMP_PARAM_DESC, &desc, sizeof(desc), &ind);
for (p = types; p->name; ++p) {
SQLSMALLINT concise_type = p->type;
if (SQL_SUCCEEDED
(SQLSetDescField(desc, 1, SQL_DESC_CONCISE_TYPE, int2ptr(concise_type), sizeof(SQLSMALLINT)))) {
SQLSMALLINT concise_type, type, code;
concise_type = type = code = 0;
SQLGetDescField(desc, 1, SQL_DESC_TYPE, &type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_CONCISE_TYPE, &concise_type, sizeof(SQLSMALLINT), &ind);
SQLGetDescField(desc, 1, SQL_DESC_DATETIME_INTERVAL_CODE, &code, sizeof(SQLSMALLINT), &ind);
printf("Setted type %s -> [%d (%s), %d (%s), %d]\n",
p->name, (int) concise_type, get_type_name(concise_type), (int) type, get_type_name(type), code);
check_msg(p->flags & FLAG_SQL, "Type not SQL successed to be set in IPD");
} else {
fprintf(stderr, "Error setting type %d (%s)\n", (int) p->type, p->name);
check_msg(!(p->flags & FLAG_SQL), "Type SQL failed to be set in IPD");
}
}
odbc_disconnect();
return result;
}
CDB_Object* CODBC_RowResult::x_LoadItem(I_Result::EGetItem policy, CDB_Object* item_buf)
{
char buffer[8*1024];
int outlen;
switch(m_ColFmt[m_CurrItem].DataType) {
case SQL_WCHAR:
case SQL_WVARCHAR:
switch (item_buf->GetType()) {
case eDB_VarBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_VarBinary*)item_buf)->SetValue(buffer, outlen);
break;
case eDB_Binary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_Binary*)item_buf)->SetValue(buffer, outlen);
break;
case eDB_LongBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_LongBinary*)item_buf)->SetValue(buffer, outlen);
break;
#ifdef HAVE_WSTRING
case eDB_VarChar:
outlen = xGetData(SQL_C_WCHAR, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else *((CDB_VarChar*)item_buf) = CODBCString((wchar_t*)buffer).ConvertTo(GetClientEncoding());
break;
case eDB_Char:
outlen = xGetData(SQL_C_WCHAR, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else *((CDB_Char*)item_buf) = CODBCString((wchar_t*)buffer).ConvertTo(GetClientEncoding());
break;
case eDB_LongChar:
outlen = xGetData(SQL_C_WCHAR, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else *((CDB_LongChar*)item_buf) = CODBCString((wchar_t*)buffer).ConvertTo(GetClientEncoding());
break;
#endif
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
case SQL_VARCHAR:
case SQL_CHAR: {
switch (item_buf->GetType()) {
case eDB_VarBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_VarBinary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_Binary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_Binary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_LongBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_LongBinary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_VarChar:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if ( outlen < 0) item_buf->AssignNULL();
else *((CDB_VarChar*) item_buf) = buffer;
break;
case eDB_Char:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if ( outlen < 0) item_buf->AssignNULL();
else *((CDB_Char*) item_buf) = buffer;
break;
case eDB_LongChar:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if ( outlen < 0) item_buf->AssignNULL();
else *((CDB_LongChar*) item_buf) = buffer;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_BINARY:
case SQL_VARBINARY: {
switch ( item_buf->GetType() ) {
case eDB_VarBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_VarBinary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_Binary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_Binary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_LongBinary:
outlen = xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
if ( outlen <= 0) item_buf->AssignNULL();
else ((CDB_LongBinary*) item_buf)->SetValue(buffer, outlen);
break;
case eDB_VarChar:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if (outlen < 0) item_buf->AssignNULL();
else *((CDB_VarChar*) item_buf) = buffer;
break;
case eDB_Char:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if (outlen < 0) item_buf->AssignNULL();
else *((CDB_Char*) item_buf) = buffer;
break;
case eDB_LongChar:
outlen = xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
if (outlen < 0) item_buf->AssignNULL();
else *((CDB_LongChar*) item_buf) = buffer;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_BIT: {
SQLCHAR v;
switch ( item_buf->GetType() ) {
case eDB_Bit:
outlen = xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Bit*) item_buf) = (int) v;
break;
case eDB_TinyInt:
outlen = xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_TinyInt*) item_buf) = v ? 1 : 0;
break;
case eDB_SmallInt:
outlen = xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_SmallInt*) item_buf) = v ? 1 : 0;
break;
case eDB_Int:
outlen = xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Int*) item_buf) = v ? 1 : 0;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_TYPE_TIMESTAMP: {
SQL_TIMESTAMP_STRUCT v;
switch ( item_buf->GetType() ) {
case eDB_SmallDateTime: {
outlen = xGetData(SQL_C_TYPE_TIMESTAMP, &v, sizeof(SQL_TIMESTAMP_STRUCT));
if (outlen <= 0) item_buf->AssignNULL();
else {
CTime t((int)v.year, (int)v.month, (int)v.day,
(int)v.hour, (int)v.minute, (int)v.second,
(long)v.fraction);
*((CDB_SmallDateTime*) item_buf)= t;
}
break;
}
case eDB_DateTime: {
outlen = xGetData(SQL_C_TYPE_TIMESTAMP, &v, sizeof(SQL_TIMESTAMP_STRUCT));
if (outlen <= 0) item_buf->AssignNULL();
else {
CTime t((int)v.year, (int)v.month, (int)v.day,
(int)v.hour, (int)v.minute, (int)v.second,
(long)v.fraction);
*((CDB_DateTime*) item_buf)= t;
}
break;
}
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_TINYINT: {
SQLCHAR v;
switch ( item_buf->GetType() ) {
case eDB_TinyInt:
outlen = xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_TinyInt*) item_buf) = (Uint1) v;
break;
case eDB_SmallInt:
outlen = xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_SmallInt*) item_buf) = (Int2) v;
break;
case eDB_Int:
outlen = xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Int*) item_buf) = (Int4) v;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_SMALLINT: {
SQLSMALLINT v;
switch ( item_buf->GetType() ) {
case eDB_SmallInt:
outlen = xGetData(SQL_C_SSHORT, &v, sizeof(SQLSMALLINT));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_SmallInt*) item_buf) = (Int2) v;
break;
case eDB_Int:
outlen = xGetData(SQL_C_SSHORT, &v, sizeof(SQLSMALLINT));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Int*) item_buf) = (Int4) v;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_INTEGER: {
SQLINTEGER v;
switch ( item_buf->GetType() ) {
case eDB_Int:
outlen = xGetData(SQL_C_SLONG, &v, sizeof(SQLINTEGER));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Int*) item_buf) = (Int4) v;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_DOUBLE:
case SQL_FLOAT: {
SQLDOUBLE v;
switch ( item_buf->GetType() ) {
case eDB_Double:
outlen = xGetData(SQL_C_DOUBLE, &v, sizeof(SQLDOUBLE));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Double*) item_buf) = v;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_REAL: {
SQLREAL v;
switch ( item_buf->GetType() ) {
case eDB_Float:
outlen = xGetData(SQL_C_FLOAT, &v, sizeof(SQLREAL));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_Float*) item_buf) = v;
break;
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_BIGINT:
case SQL_DECIMAL:
case SQL_NUMERIC: {
switch ( item_buf->GetType() ) {
case eDB_Numeric: {
SQL_NUMERIC_STRUCT v;
SQLHDESC hdesc;
SQLGetStmtAttr(GetHandle(), SQL_ATTR_APP_ROW_DESC, &hdesc, 0, NULL);
SQLSetDescField(hdesc, m_CurrItem + 1, SQL_DESC_TYPE, (VOID*)SQL_C_NUMERIC, 0);
SQLSetDescField(hdesc, m_CurrItem + 1, SQL_DESC_PRECISION,
(VOID*)(m_ColFmt[m_CurrItem].ColumnSize), 0);
SQLSetDescField(hdesc, m_CurrItem + 1, SQL_DESC_SCALE,
reinterpret_cast<VOID*>(m_ColFmt[m_CurrItem].DecimalDigits), 0);
// outlen = xGetData(SQL_ARD_TYPE, &v, sizeof(SQL_NUMERIC_STRUCT));
outlen = xGetData(SQL_C_NUMERIC, &v, sizeof(SQL_NUMERIC_STRUCT));
if (outlen <= 0) item_buf->AssignNULL();
else xConvert2CDB_Numeric((CDB_Numeric*)item_buf, v);
break;
}
case eDB_BigInt: {
SQLBIGINT v;
outlen = xGetData(SQL_C_SBIGINT, &v, sizeof(SQLBIGINT));
if (outlen <= 0) item_buf->AssignNULL();
else *((CDB_BigInt*) item_buf) = (Int8) v;
break;
}
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
}
case SQL_WLONGVARCHAR:
switch(item_buf->GetType()) {
#ifdef HAVE_WSTRING
case eDB_Text: {
if (policy == I_Result::eAssignLOB) {
static_cast<CDB_Stream*>(item_buf)->Truncate();
}
while (CheckSIENoD_WText((CDB_Stream*)item_buf)) {
continue;
}
break;
}
#endif
case eDB_Image: {
if (policy == I_Result::eAssignLOB) {
static_cast<CDB_Stream*>(item_buf)->Truncate();
}
while (CheckSIENoD_Binary((CDB_Stream*)item_buf)) {
continue;
}
break;
}
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
case SQL_LONGVARBINARY:
case SQL_LONGVARCHAR:
switch(item_buf->GetType()) {
case eDB_Text:
case eDB_VarCharMax: {
if (policy == I_Result::eAssignLOB) {
static_cast<CDB_Stream*>(item_buf)->Truncate();
}
while (CheckSIENoD_Text((CDB_Stream*)item_buf)) {
continue;
}
break;
}
case eDB_Image:
case eDB_VarBinaryMax: {
if (policy == I_Result::eAssignLOB) {
static_cast<CDB_Stream*>(item_buf)->Truncate();
}
while (CheckSIENoD_Binary((CDB_Stream*)item_buf)) {
continue;
}
break;
}
default:
{
string err_message = wrong_type + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430020 );
}
}
break;
default:
{
string err_message = "Unsupported column type." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430025 );
}
}
return item_buf;
}
static int odbc_dispatch10(void)
{
unsigned long retval;
PWord rval; int rtype;
PWord arg1; int type1;
PWord arg2; int type2;
PWord arg3; int type3;
PWord arg4; int type4;
PWord arg5; int type5;
PWord arg6; int type6;
PWord arg7; int type7;
PI_getan(&arg1,&type1,1);
if (type1 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg1,type1))
PI_FAIL;
PI_getan(&arg2,&type2,2);
if (type2 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg2,type2))
PI_FAIL;
PI_getan(&arg3,&type3,3);
if (type3 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg3,type3))
PI_FAIL;
PI_getan(&arg4,&type4,4);
if (type4 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg4,type4))
PI_FAIL;
PI_getan(&arg5,&type5,5);
if (type5 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg5,type5))
PI_FAIL;
PI_getan(&arg6,&type6,6);
if (type6 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg6,type6))
PI_FAIL;
PI_getan(&arg7,&type7,7);
switch(arg1)
{
case 0:
retval = (unsigned long) SQLExtendedFetch(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLINTEGER ) arg4),((SQLUINTEGER * ) arg5),((SQLUSMALLINT * ) arg6));
break;
case 1:
retval = (unsigned long) SQLSetDescField(((SQLHDESC ) arg2),((SQLSMALLINT ) arg3),((SQLSMALLINT ) arg4),((SQLPOINTER ) arg5),((SQLINTEGER ) arg6));
break;
case 2:
retval = (unsigned long) SQLGetStmtAttr(((SQLHSTMT ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5),((SQLINTEGER * ) arg6));
break;
case 3:
retval = (unsigned long) SQLGetInfo(((SQLHDBC ) arg2),((SQLUSMALLINT ) arg3),((SQLPOINTER ) arg4),((SQLSMALLINT ) arg5),((SQLSMALLINT * ) arg6));
break;
case 4:
retval = (unsigned long) SQLGetEnvAttr(((SQLHENV ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5),((SQLINTEGER * ) arg6));
break;
case 5:
retval = (unsigned long) SQLGetConnectAttr(((SQLHDBC ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5),((SQLINTEGER * ) arg6));
break;
default:
PI_FAIL;
}
PI_makedouble(&rval,&rtype,(double) retval);
if (PI_unify(arg7,type7,rval,rtype))
PI_SUCCEED;
PI_FAIL;
}
