static int
get_attr_stmt(ATTR_PARAMS)
{
SQLINTEGER i, ind;
SQLSMALLINT si;
SQLLEN li;
SQLRETURN ret;
ret = SQL_ERROR;
switch (attr->type) {
case type_INTEGER:
case type_UINTEGER:
i = 0xdeadbeef;
ret = SQLGetStmtAttr(odbc_stmt, attr->value, (SQLPOINTER) & i, sizeof(SQLINTEGER), &ind);
break;
case type_SMALLINT:
si = 0xbeef;
ret = SQLGetStmtAttr(odbc_stmt, attr->value, (SQLPOINTER) & si, sizeof(SQLSMALLINT), &ind);
i = si;
break;
case type_LEN:
li = 0xdeadbeef;
ret = SQLGetStmtAttr(odbc_stmt, attr->value, (SQLPOINTER) & li, sizeof(SQLLEN), &ind);
i = li;
break;
case type_VOIDP:
case type_DESC:
case type_CHARP:
fatal("Line %u: CHAR* check still not supported\n", line_num);
break;
}
if (!SQL_SUCCEEDED(ret))
fatal("Line %u: failure not expected\n", line_num);
return i;
}
SQLRETURN unixodbc_backend_debug::do_get_statement_attribute(SQLHSTMT statement_handle, SQLINTEGER attribute, SQLPOINTER value_ptr, SQLINTEGER buffer_length, SQLINTEGER * string_length_ptr) const
{
std::cout << " *DEBUG* get_statement_attribute";
auto const return_code = SQLGetStmtAttr(statement_handle, attribute, value_ptr, buffer_length, string_length_ptr);
std::cout << " (return code " << return_code << ")" << std::endl;
return return_code;
}
/**
* Check if query was executed
*
* @param chan R ODBC handle
* @retval 0 if query not executed, 1 if query executed, -1 on error
*/
SEXP RODBCQueryStatus(SEXP chan){
pRODBCHandle thisHandle = R_ExternalPtrAddr(chan);
SQLRETURN res = 0;
SQLINTEGER len;
SQLCHAR sqlState[6];
SQLINTEGER nativeError;
SQLSMALLINT msgLen;
res = SQLGetStmtAttr(thisHandle->hStmt, SQL_ATTR_ROW_NUMBER, NULL, 0, &len);
if(res != SQL_SUCCESS && res != SQL_SUCCESS_WITH_INFO){
/* get the error code */
res = SQLGetDiagRec(SQL_HANDLE_STMT, thisHandle->hStmt, 1, sqlState, &nativeError, NULL, 0, &msgLen);
if(res != SQL_SUCCESS && res != SQL_SUCCESS_WITH_INFO){
return ScalarInteger(-1);
}
/* check if it is an INVALID CURSOR STATE error */
if(strncmp((const char *)sqlState, "24000", 5) == 0){
return ScalarInteger(0);
}
/* check if it is an NOT POSITIONED ON A VALID ROW error */
if(strncmp((const char *)sqlState, "07005", 5) == 0){
return ScalarInteger(1);
}
warning(_("SQL error code: %s"), sqlState);
return ScalarInteger(-1);
}
return ScalarInteger(1);
}
/**
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;
}
RETCODE SQL_API SQLGetStmtAttrW ( SQLHSTMT pStmt,
SQLINTEGER pAttr,
SQLPOINTER pDataPtr,
SQLINTEGER pDataSize,
SQLINTEGER* pDataSizePtr ) {
__ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLGetStmtAttrW, Attr: %d, DataPtr: %d, DataSize: %d", pAttr, pDataPtr,
pDataSize ) );
return SQLGetStmtAttr ( pStmt, pAttr, pDataPtr, pDataSize, pDataSizePtr );
}
ODBC_INTERFACE RETCODE SQL_API
SQLGetStmtAttrW (SQLHSTMT StatementHandle,
SQLINTEGER Attribute,
SQLPOINTER Value,
SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
OutputDebugString ("SQLGetStmtAttrW called\n");
return SQLGetStmtAttr (StatementHandle, Attribute, Value, BufferLength, StringLength);
}
SQLRETURN SQL_API
SQLGetStmtAttrA(SQLHSTMT StatementHandle,
SQLINTEGER Attribute,
SQLPOINTER ValuePtr,
SQLINTEGER BufferLength,
SQLINTEGER *StringLengthPtr)
{
return SQLGetStmtAttr(StatementHandle,
Attribute,
ValuePtr,
BufferLength,
StringLengthPtr);
}
//
// returns true/false if descriptor has/hasn't bookmark record
//
int hasBookmarkRecord (SQLHANDLE handle) {
SQLRETURN retcode;
SQLULEN bookmark;
retcode = SQLGetStmtAttr(handle, SQL_ATTR_USE_BOOKMARKS,
&bookmark, 0, 0);
if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
extract_error("SQLGetStmtAttr (SQL_ATTR_USE_BOOKMARKS)",
handle, SQL_HANDLE_ENV);
return 0;
}
if (bookmark==SQL_UB_OFF)
return 0;
else
return 1;
}
static void
check_attr_ard(ATTR_PARAMS)
{
SQLINTEGER i, ind;
SQLSMALLINT si;
SQLLEN li;
SQLRETURN ret;
SQLHDESC desc = SQL_NULL_HDESC;
char buf[128];
/* get ARD */
SQLGetStmtAttr(odbc_stmt, SQL_ATTR_APP_ROW_DESC, &desc, sizeof(desc), &ind);
ret = SQL_ERROR;
switch (attr->type) {
case type_INTEGER:
i = 0xdeadbeef;
ret = SQLGetDescField(desc, 1, attr->value, (SQLPOINTER) & i, sizeof(SQLINTEGER), &ind);
break;
case type_SMALLINT:
si = 0xbeef;
ret = SQLGetDescField(desc, 1, attr->value, (SQLPOINTER) & si, sizeof(SQLSMALLINT), &ind);
i = si;
break;
case type_LEN:
li = 0xdeadbeef;
ret = SQLGetDescField(desc, 1, attr->value, (SQLPOINTER) & li, sizeof(SQLLEN), &ind);
i = li;
break;
case type_CHARP:
ret = SQLGetDescField(desc, 1, attr->value, buf, sizeof(buf), &ind);
if (!SQL_SUCCEEDED(ret))
fatal("Line %u: failure not expected\n", line_num);
if (strcmp(buf, expected_value) != 0) {
g_result = 1;
fprintf(stderr, "Line %u: invalid %s got %s expected %s\n", line_num, attr->name, buf, expected_value);
}
return;
}
if (!SQL_SUCCEEDED(ret))
fatal("Line %u: failure not expected\n", line_num);
if (i != lookup(expected_value, attr->lookup)) {
g_result = 1;
fprintf(stderr, "Line %u: invalid %s got %ld expected %s\n", line_num, attr->name, (long int) i, expected_value);
}
}
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;
}
/*
---------------------------------------------------------
TestSQLGetDescRec
---------------------------------------------------------
*/
PassFail TestMXSQLGetDescRec(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt, hstmt1;
//Common input params to the apis
SQLHDESC hIrd, hImArd, hImIrd, hImApd, hImIpd, hExArd, hExApd;
SWORD RecNumber = 0;
//SQLGetDescRec: params
SQLHDESC getDescRecHandle; //input
SWORD getDescRecNumber; //input
TCHAR getDescName[MAXLEN];
SWORD getNameMaxLength; //input; MAXLEN = 100 : defined in Common.h
SWORD getDescNameActualLength;
SQLSMALLINT getDescType;
SWORD getDescIntervalCode;
SQLLEN getDescOctectLength;
SWORD getDescPrecision;
SWORD getDescScale;
SWORD getDescNullable;
//SQLSetDescRec: params
SQLHDESC setDescRecHandle;
SQLSMALLINT setDescRecNumber;
SQLSMALLINT setDescType;
SQLSMALLINT setDescIntervalCode;
SQLINTEGER setDescOctetLength;
SQLSMALLINT setDescPrecision;
SQLSMALLINT setDescScale;
SQLPOINTER setDescDataPtr;
SQLLEN setDescOctectLengthPtr;
SQLLEN setDescIndicatorPtr;
TCHAR setDescName[1];
SQLINTEGER setDescNullable = SQL_NULL_DATA;
short int i;
// Template for a Descriptor record
typedef struct {
// TCHAR DescName[MAXLEN];
TCHAR *DescName;
short int DescType;
short int DescDatetimeIntervalCode;
short int DescOctetLength;
short int DescPrecision;
short int DescScale;
void* DescDataPtr;
short int DescOctectLengthPtr;
short int DescIndicatorPtr;
short int DescNullable;
}DescRec;
DescRec TestDataAPD[DATA_ARR_LEN] =
{
//APD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataARD[DATA_ARR_LEN] =
{
//ARD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataIPD[DATA_ARR_LEN] =
{
//IPD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, 0, 0, 0, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, 0, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataIRD[DATA_ARR_LEN] =
{
//IRD can only be read
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
_tcscpy(setDescName, _T(""));
// ================================================================================================================
// begin common test setup
//==================================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLSetDescRec and SQLGetDescRec.\n"));
TEST_INIT;
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//Explicit APD
//allocate an Explicit APD desc
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//Explicit ARD
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//===============================================================================================================
// Begin Testing:Positive Test for Implicit APD
//===============================================================================================================
//Get Implicit APD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hImApd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Implicit APD tests.\n"));
TEST_FAILED;
goto ExAPDtests; // transfers control to the next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit APD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImApd ;
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
/*LogMsg(NONE,_T("SQLSetDescRec(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"),
setDescRecNumber,
setDescType,
setDescIntervalCode,
setDescOctetLength ,
setDescPrecision,
setDescScale,
setDescDataPtr,
setDescOctectLengthPtr,
setDescIndicatorPtr); */
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec "))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit APD Descriptor
//LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n");
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit APD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//begin checking APD values ----------
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for APD
//===============================================================================================================
// Begin Testing:Positive Test for Explicit APD
//===============================================================================================================
ExAPDtests: ; // beginning next set of tests
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n");
//Get Explicit APD handle
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get Explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Explicit APD tests.\n"));
TEST_FAILED;
//TEST_RETURN;
goto ARDtests; // transfers control to the next set of tests
}
//associate with a statement
returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, (SQLPOINTER)hExApd, SQL_IS_POINTER);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot set Explicit APD for statement.\n"));
TEST_FAILED;
}
setDescRecHandle = hExApd ;
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
/*LogMsg(NONE,_T("SQLSetDescRect(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"),
setDescRecNumber,
setDescType,
setDescIntervalCode,
setDescOctetLength ,
setDescPrecision,
setDescScale,
setDescDataPtr,
setDescOctectLengthPtr,
setDescIndicatorPtr);*/
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Explicit APD Descriptor
//LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n");
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Explicit APD.\n"));
getDescRecHandle = setDescRecHandle;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
continue;
}
//begin checking APD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for Explicit APD
//===============================================================================================================
// Begin Testing: Statement reverts to Implicit APD after freeing Explicit Descriptor
//===============================================================================================================
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "SQLGetDescRec for Explicit-Implicit APD: statement reverts to implicit descriptor after explicit descriptor has been freed.\n");
//free Explicit APD
returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for APD)"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot free explicit descriptor: Aborting Explicit-Implicit Descriptor tests.\n"));
TEST_FAILED;
goto ARDtests; // transfers control to the next set of tests
}
//Use the previously allocated Implicit APD handle
getDescRecHandle = hImApd;
TESTCASE_BEGIN("Test that the implicit descriptor get associated with statement after explicit descriptor has been freed.\n");
//set multiple Fields
i = 0;
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
//Get the Implicit APD Descriptor
LogMsg(NONE,_T("SQLGetDescRec: tests for Explicit-Implicit Descriptor.\n"));
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: tests for Explicit-Implicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
//continue;
}
//begin checking APD values ----------
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
//==================================================================================================================
// Begin Testing: Positive Test for Implicit ARD
//===================================================================================================================
ARDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n");
//Get Implicit ARD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImArd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n"));
TEST_FAILED;
goto ExARDtests; //go to next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImArd ;
setDescRecNumber = RecNumber;
setDescType = TestDataARD[i].DescType;
setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataARD[i].DescOctetLength;
setDescPrecision = TestDataARD[i].DescPrecision;
setDescScale = TestDataARD[i].DescScale;
setDescDataPtr = TestDataARD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit ARD Descriptor
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit ARD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataARD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
break;
}
//begin checking ARD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for ARD
//==================================================================================================================
// Begin Testing: Positive Test for Explicit ARD
//===================================================================================================================
ExARDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n");
//Get Explicit ARD handle
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n"));
TEST_FAILED;
goto IPDtests; //go to next set of tests
}
//associate with a statement
returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, (SQLPOINTER)hExArd, SQL_IS_POINTER);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot set Explicit ARD for statement.\n"));
TEST_FAILED;
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hExArd ;
setDescRecNumber = RecNumber;
setDescType = TestDataARD[i].DescType;
setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataARD[i].DescOctetLength;
setDescPrecision = TestDataARD[i].DescPrecision;
setDescScale = TestDataARD[i].DescScale;
setDescDataPtr = TestDataARD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i);
TEST_FAILED;
continue;
}
//Get the Explicit ARD Descriptor
LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Explicit ARD.\n"));
getDescRecHandle = hExArd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataARD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i);
TEST_FAILED;
break;
}
//begin checking ARD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"), getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for Explicit ARD
//free explicit ARD
returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for ARD)"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
//======================================================================================================================
// Begin Testing: Positive Test for Implicit IPD
//=====================================================================================================================
IPDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n");
//Get Implicit IPD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImIpd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IPD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get IPD: Aborting Implicit IPD tests.\n"));
TEST_FAILED;
goto IRDtests; //go to next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataIPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImIpd ;
setDescRecNumber = RecNumber;
setDescType = TestDataIPD[i].DescType;
setDescIntervalCode = TestDataIPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataIPD[i].DescOctetLength;
setDescPrecision = TestDataIPD[i].DescPrecision;
setDescScale = TestDataIPD[i].DescScale;
setDescDataPtr = TestDataIPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataIPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataIPD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode, "SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit IPD Descriptor
LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Implicit IPD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataIPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//begin checking IPD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"), getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for IPD
//==================================================================================================================
// Begin Testing: Posituve Tests for IRD (IRD Desc Fields are read only)
//==================================================================================================================
IRDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IRD.\n");
//Get Implicit IRD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hImIrd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get IRD: Aborting Implicit IRD tests.\n"));
TEST_FAILED;
// TEST_RETURN; //this will abort tests and perform a full disconnect.
}
//---------------------------------------------------------------------------------------------------------
TESTCASE_BEGIN("Test SQLSetDescRec for Implicit IRD: IRD Descriptor Fields cannot be set by the application.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImIrd ;
setDescRecNumber = RecNumber;
setDescType = TestDataIRD[i].DescType;
setDescIntervalCode = TestDataIRD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataIRD[i].DescOctetLength;
setDescPrecision = TestDataIRD[i].DescPrecision;
setDescScale = TestDataIRD[i].DescScale;
setDescDataPtr = TestDataIRD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataIRD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataIRD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_ERROR,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
TESTCASE_END;
//-------------------------------------------------------------------------------------------------------------
TESTCASE_BEGIN("Test SQLGetDescRec for Implicit IRD: IRD Descriptor Fields not populated before call to DB.\n");
//This testcases use the Implicit IRD handle obtained in previous testcase
returncode = SQLGetDescRec(hImIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_NO_DATA_FOUND,returncode,"SQLGetDescField"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
//TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited.
}
TESTCASE_END;
//===============================================================================================================
// Begin Testing:Positive Test for populated Implicit IRD
//===============================================================================================================
TESTCASE_BEGIN("Test SQLGetDescRec for populated Implicit IRD.\n");
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of (SQLSetDescRec) and SQLGetDescRec for Implicit IRD.\n");
//alloc new handle
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot allocate statement: Aborting populated Implicit IRD tests.\n"));
FullDisconnect(pTestInfo);
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//Get Implicit IRD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hIrd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IRD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting populated Implicit IRD tests.\n"));
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//populate the IRD by executing an catalog api
returncode = SQLGetTypeInfo(hstmt1, SQL_ALL_TYPES);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo: population of IRD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot execute statement: Aborting populated Implicit IRD tests.\n"));
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//check IRD
returncode = SQLGetDescRec(hIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescField"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
TEST_FAILED;
//TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited.
}
TESTCASE_END;
// free implicitly allocated descriptors by freeing statement
returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
TEST_FAILED;
}
//===========================================================================================================
// begin cleanup
//==============================================================================================================
Cleanup: ;
// free implicitly allocated descriptors by freeing statement
returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLSetDescRec and SQLGetDescRec.\n"));
TEST_RETURN;
} //end of test ****************
static void
print_results(SQLHSTMT hStmt)
{
static const char dashes[] = "----------------------------------------------------------------" /* each line is 64 */
"----------------------------------------------------------------"
"----------------------------------------------------------------"
"----------------------------------------------------------------";
struct METADATA *metadata = NULL;
struct DATA *data = NULL;
SQLSMALLINT ncols = 0;
RETCODE erc;
int c, ret;
/*
* Process each resultset
*/
do {
/* free metadata, in case it was previously allocated */
free_metadata(metadata, data, ncols);
metadata = NULL;
data = NULL;
ncols = 0;
/*
* Allocate memory for metadata and bound columns
*/
if ((erc = SQLNumResultCols(hStmt, &ncols)) != SQL_SUCCESS){
odbc_perror(hStmt, erc, "SQLNumResultCols", "failed");
exit(EXIT_FAILURE);
}
metadata = (struct METADATA*) calloc(ncols, sizeof(struct METADATA));
assert(metadata);
data = (struct DATA*) calloc(ncols, sizeof(struct DATA));
assert(data);
/*
* For each column, get its name, type, and size.
* Allocate a buffer to hold the data, and bind the buffer to the column.
* "bind" here means to give the address of the buffer we want filled as each row is fetched.
*/
fprintf(options.verbose, "Metadata\n");
fprintf(options.verbose, "%-6s %-30s %-10s %-18s %-6s %-6s \n",
"col", "name", "type value", "type name", "size", "varies");
fprintf(options.verbose, "%.6s %.30s %.10s %.18s %.6s %.6s \n",
dashes, dashes, dashes, dashes, dashes, dashes);
for (c=0; c < ncols; c++) {
/* Get and print the metadata. Optional: get only what you need. */
SQLCHAR name[512];
SQLSMALLINT namelen, ndigits, fnullable;
if ((erc = SQLDescribeCol(hStmt, c+1, name, sizeof(name), &namelen,
&metadata[c].type, &metadata[c].size,
&ndigits, &fnullable)) != SQL_SUCCESS) {
odbc_perror(hStmt, erc, "SQLDescribeCol", "failed");
exit(EXIT_FAILURE);
}
assert(namelen < sizeof(name));
name[namelen] = '\0';
metadata[c].name = strdup((char *) name);
metadata[c].width =
(ndigits >= 0 && (unsigned) ndigits > metadata[c].size)? ndigits : metadata[c].size;
if (is_character_data(metadata[c].type)) {
SQLHDESC hDesc;
SQLINTEGER buflen;
metadata[c].nchars = metadata[c].size;
if ((erc = SQLGetStmtAttr(hStmt, SQL_ATTR_IMP_ROW_DESC, &hDesc, sizeof(hDesc), NULL)) != SQL_SUCCESS) {
odbc_perror(hStmt, erc, "SQLGetStmtAttr", "failed");
exit(EXIT_FAILURE);
}
if ((erc = SQLGetDescField(hDesc, c+1, SQL_DESC_OCTET_LENGTH,
&metadata[c].size, sizeof(metadata[c].size),
&buflen)) != SQL_SUCCESS) {
odbc_perror(hStmt, erc, "SQLGetDescField", "failed");
exit(EXIT_FAILURE);
}
metadata[c].size = metadata[c].size * 2 + 1;
}
fprintf(options.verbose, "%6d %30s %10d %18s %6lu %6d \n",
c+1, metadata[c].name, (int)metadata[c].type, prtype(metadata[c].type),
(long unsigned int) metadata[c].size, -1);
#if 0
fprintf(options.verbose, "%6d %30s %30s %15s %6d %6d \n",
c+1, metadata[c].name, metadata[c].source, dbprtype(metadata[c].type),
metadata[c].size, dbvarylen(dbproc, c+1));
metadata[c].width = get_printable_size(metadata[c].type, metadata[c].size);
if (metadata[c].width < strlen(metadata[c].name))
metadata[c].width = strlen(metadata[c].name);
#endif
/*
* Build the column header format string, based on the column width.
* This is just one solution to the question, "How wide should my columns be when I print them out?"
*/
ret = set_format_string(&metadata[c], (c+1 < ncols)? options.colsep : "\n");
if (ret <= 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
/*
* Bind the column to our variable.
* We bind everything to strings, because we want to convert everything to strings for us.
* If you're performing calculations on the data in your application, you'd bind the numeric data
* to C integers and floats, etc. instead.
*
* It is not necessary to bind to every column returned by the query.
* Data in unbound columns are simply never copied to the user's buffers and are thus
* inaccesible to the application.
*/
data[c].buffer = calloc(1, bufsize(&metadata[c]));
assert(data[c].buffer);
if ((erc = SQLBindCol(hStmt, c+1, SQL_C_CHAR, (SQLPOINTER)data[c].buffer,
bufsize(&metadata[c]), &data[c].len)) != SQL_SUCCESS){
odbc_perror(hStmt, erc, "SQLBindCol", "failed");
exit(EXIT_FAILURE);
}
}
if (!options.fquiet) {
/* Print the column headers to stderr to keep them separate from the data. */
for (c=0; c < ncols; c++) {
fprintf(options.headers, metadata[c].format_string, metadata[c].name);
}
/* Underline the column headers. */
for (c=0; c < ncols; c++) {
fprintf(options.headers, metadata[c].format_string, dashes);
}
}
/*
* Print the data to stdout.
*/
while (ncols > 0 && (erc = SQLFetch(hStmt)) != SQL_NO_DATA) {
switch(erc) {
case SQL_SUCCESS_WITH_INFO:
print_error_message(SQL_HANDLE_STMT, hStmt);
case SQL_SUCCESS:
break;
default:
odbc_perror(hStmt, erc, "SQLFetch", "failed");
exit(EXIT_FAILURE);
}
for (c=0; c < ncols; c++) {
switch (data[c].len) { /* handle nulls */
case SQL_NULL_DATA: /* is null */
fprintf(stdout, metadata[c].format_string, "NULL");
break;
default:
assert(data[c].len >= 0);
case SQL_NO_TOTAL:
fprintf(stdout, metadata[c].format_string, data[c].buffer);
break;
}
}
}
if (ncols > 0 && erc == SQL_NO_DATA)
print_error_message(SQL_HANDLE_STMT, hStmt);
erc = SQLMoreResults(hStmt);
fprintf(options.verbose, "SQLMoreResults returned %s\n", prret(erc));
switch (erc) {
case SQL_NO_DATA:
print_error_message(SQL_HANDLE_STMT, hStmt);
break;
case SQL_SUCCESS_WITH_INFO:
print_error_message(SQL_HANDLE_STMT, hStmt);
case SQL_SUCCESS:
continue;
default:
odbc_perror(hStmt, erc, "SQLMoreResults", "failed");
exit(EXIT_FAILURE);
}
} while (erc != SQL_NO_DATA);
if (erc != SQL_NO_DATA) {
assert(erc != SQL_STILL_EXECUTING);
odbc_perror(hStmt, erc, "SQLMoreResults", "failed");
exit(EXIT_FAILURE);
}
}
/* TODO zaimplementowac FETCH_NEXT */
long db2_bmd_db_result_get_value(void *hDB,void *hRes,long which_row,long which_column,char **value,
EnumDbFetchMode_t fetch_mode,long *successfully_fetched)
{
PRINT_INFO("\n");
DB_bmd_db_conn_t *db_conn=NULL;
//DB_bmd_db_result_t *db_res=NULL;
SQLRETURN rc;
/* walidacja parametrow */
/******************************/
if(hDB==NULL) { BMD_FOK(BMD_DB_INVALID_CONNECTION_HANDLE); }
if(which_row<0) { BMD_FOK(BMD_ERR_PARAM3); }
if(which_column<0) { BMD_FOK(BMD_ERR_PARAM4); }
if(value == NULL) { BMD_FOK(BMD_ERR_PARAM5); }
if(*value != NULL) { BMD_FOK(BMD_ERR_PARAM5); }
if(successfully_fetched == NULL) { BMD_FOK(BMD_ERR_PARAM6); }
if(*successfully_fetched < 0) { BMD_FOK(BMD_ERR_PARAM6); }
if( (*((long *)(hDB)) != BMD_DBCONN_MAGIC ) )
return BMD_ERR_INVALID_PTR;
db_conn=(DB_bmd_db_conn_t *)hDB;
//db_res=(DB_bmd_db_result_t *)hRes;
/*
* Only FETCH_NEXT mode implemented *
*/
//if(which_column != 0)
// return BMD_ERR_FORMAT;
if(*successfully_fetched == 0){
rc = SQLFetch(*(db_conn->hstmt));
long ret = print_error(rc, "SQLFetch");
if(ret!=BMD_OK)
{
if(ret == 5)
return BMD_ERR_NODATA;
else{
extract_error("SQLAllocHandle", *(db_conn->hstmt), SQL_HANDLE_STMT);
return BMD_DB_EXECUTION_ERROR;
}
}
}
int colNum = 0;
SQLINTEGER sql_ub;
rc = SQLGetStmtAttr( *(db_conn->hstmt), SQL_ATTR_USE_BOOKMARKS, &sql_ub, 0, NULL ) ;
if(print_error(rc, "SQLGetStmtAttr") != BMD_OK)
return BMD_ERR_OP_FAILED;
if ( sql_ub == SQL_UB_OFF )
colNum = which_column + 1;
else
colNum = which_column;
//SQLCHAR *
SQLINTEGER indicator;
//TODO - koniecznie zrobiæ bufor dynamiczny!!!
SQLCHAR buf[32000];
/* retrieve column data as a string */
rc = SQLGetData(*(db_conn->hstmt), colNum, SQL_C_CHAR, buf, sizeof(buf), &indicator);
long retu = print_error(rc, "SQLGetData");
if(retu!=BMD_OK)
{
if(retu == 5)
return BMD_ERR_NODATA;
else
return BMD_ERR_OP_FAILED;
}
//PRINT_INFO("Indicator: %d\n", (int)indicator);
if(indicator <= 0)
{
//PRINT_INFO("Pobrano pust¹ wartoœæ\n");
asprintf(value,"%s","");
return BMD_OK;
}
asprintf(value,"%s",buf);
return BMD_OK;
}
long db2_bmd_db_result_get_row(void *hDB,void *hRes,long which_row,long max_columns,db_row_strings_t **rowstruct,
EnumDbFetchMode_t fetch_mode,long *successfully_fetched)
{
long err = 0;
SQLRETURN rc;
DB_bmd_db_conn_t *db_conn=NULL;
//DB_bmd_db_result_t *db_res=NULL;
//SQLUINTEGER rowsFetchedNb = 0;
SQLSMALLINT nResultCols=0;
long colsprocess = 0;
long i = 0;
/******************************/
/* walidacja parametrow */
/******************************/
if(hDB==NULL) { BMD_FOK(BMD_DB_INVALID_CONNECTION_HANDLE); }
if(which_row < 0) { BMD_FOK(BMD_ERR_PARAM3); }
if(max_columns < 0) { BMD_FOK(BMD_ERR_PARAM4); }
if(rowstruct == NULL) { BMD_FOK(BMD_ERR_PARAM5); }
if(*rowstruct != NULL) { BMD_FOK(BMD_ERR_PARAM5); }
if( (*((long *)(hDB)) != BMD_DBCONN_MAGIC ) )
return BMD_ERR_INVALID_PTR;
db_conn=(DB_bmd_db_conn_t *)hDB;
if( fetch_mode == FETCH_ABSOLUTE )
return BMD_ERR_FORMAT;
else
if( fetch_mode == FETCH_NEXT )
;
else
{
return BMD_ERR_FORMAT;
}
*rowstruct = (db_row_strings_t *) malloc ( sizeof(db_row_strings_t) );
if(*rowstruct == NULL)
{
PRINT_ERROR("LIBBMDPGERR Memory error. Error=%i\n",NO_MEMORY);
return NO_MEMORY;
}
memset(*rowstruct, 0, sizeof(db_row_strings_t));
/* identify the output columns */
rc = SQLNumResultCols( *(db_conn->hstmt), &nResultCols);
if(rc != SQL_SUCCESS)
{
extract_error("SQLNumResultCols", *(db_conn->hstmt), SQL_HANDLE_STMT);
return BMD_DB_EXECUTION_ERROR;
}
if(max_columns <= 0)
{
colsprocess = nResultCols;
}
else
{
colsprocess = (nResultCols < max_columns)? nResultCols:max_columns;
}
/* przetwarzam mniejsza wartosc z colsreturned i max_columns */
(*rowstruct)->size = colsprocess;
(*rowstruct)->colvals = (char **) malloc (sizeof(char *) * colsprocess);
if((*rowstruct)->colvals == NULL)
{
PRINT_ERROR("LIBBMDPGERR Memory error. Error=%i\n",NO_MEMORY);
return NO_MEMORY;
}
memset((*rowstruct)->colvals, 0, sizeof(char *) * colsprocess);
/*
* set up the values to return fetch information into
*/
rc = SQLFetch(*(db_conn->hstmt));
long ret = print_error(rc, "SQLFetch");
if(ret!=BMD_OK)
{
if(ret == 5)
{
PRINT_INFO("No Data Found\n");
return BMD_ERR_NODATA;
}
else{
extract_error("SQLAllocHandle", *(db_conn->hstmt), SQL_HANDLE_STMT);
return BMD_DB_EXECUTION_ERROR;
}
}
int colNum = 0;
SQLINTEGER sql_ub;
rc = SQLGetStmtAttr( *(db_conn->hstmt), SQL_ATTR_USE_BOOKMARKS, &sql_ub, 0, NULL ) ;
if(print_error(rc, "SQLGetStmtAttr") != BMD_OK)
{
extract_error("SQLGetStmtAttr,SQL_ATTR_USE_BOOKMARKS ", *(db_conn->hstmt), SQL_HANDLE_STMT);
return BMD_DB_EXECUTION_ERROR;
}
if ( sql_ub == SQL_UB_OFF )
colNum = 1;
else
colNum = 0;
/* Wypelnij wszystkie stringi z wiersza */
for(i=0; i<colsprocess; i++)
{
/* retrieve column data as a string */
SQLINTEGER indicator;
//TODO - koniecznie zrobiæ bufor dynamiczny!!!
SQLCHAR buf[32000];
rc = SQLGetData(*(db_conn->hstmt), i+colNum, SQL_C_CHAR, buf, sizeof(buf), &indicator);
if (print_error(rc, "SQLGetData") != BMD_OK)
{
extract_error("SQLGetData", *(db_conn->hstmt), SQL_HANDLE_STMT);
return BMD_DB_EXECUTION_ERROR;
}
if(indicator > 0)
asprintf(&((*rowstruct)->colvals[i]),"%s",buf);
else
asprintf(&((*rowstruct)->colvals[i]),"%s","");
}
return err;
}
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;
}
SQLRETURN unixodbc_backend::do_get_statement_attribute(SQLHSTMT statement_handle, SQLINTEGER attribute, SQLPOINTER value_ptr, SQLINTEGER buffer_length, SQLINTEGER * string_length_ptr) const
{
return SQLGetStmtAttr(statement_handle, attribute, value_ptr, buffer_length, string_length_ptr);
}
bool CDbStmt::Bind()
{
assert (myRow == -1) ;
// call SQLNumResultCols to calculate the number of columns
SQLSMALLINT nCols;
SQLRETURN nResult;
if (!myHSTMT)
return false;
do {
nResult = SQLNumResultCols(*myHSTMT, &nCols);
if (nResult != SQL_ERROR && nCols == 0) {
SQLRETURN nResultMore = SQLMoreResults(*myHSTMT);
if (!SQL_SUCCEEDED(nResultMore))
break;
} else
break;
} while (nResult != SQL_ERROR && nCols == 0);
if (nResult == SQL_ERROR || nCols == 0) {
// Close the open result set.
myHSTMT->Close();
myHSTMT = NULL;
return false;
} else {
myCols = new CDbCol[(myColN = nCols)+1];
}
CDbLib *dbLib = GetDbConn()->GetDbLib();
SQLSMALLINT nColName;
SQLSMALLINT i;
int nAlloc;
myColMap.Clear();
nAlloc = 0;
for(i = 0; myCols && i < myColN; i++) {
myCols[i].Name.Grow(3);
SQLDescribeCol(*myHSTMT, i+1, (LPSQLC) (const char *) myCols[i].Name, 2, &nColName, &myCols[i].Type, &myCols[i].Size,
&myCols[i].Digits, &myCols[i].Null);
if (nColName) {
myCols[i].Name.Grow(nColName);
SQLDescribeCol(*myHSTMT, i+1, (LPSQLC) (const char *) myCols[i].Name, nColName+1, &nColName,
&myCols[i].Type, &myCols[i].Size,
&myCols[i].Digits, &myCols[i].Null);
} else {
SQLColAttribute(*myHSTMT, i+1, SQL_DESC_CATALOG_NAME,
0, 0, &nColName, 0);
if (nColName) {
myCols[i].Name.Grow(nColName);
SQLColAttribute(*myHSTMT, i+1, SQL_DESC_CATALOG_NAME,
(LPSQLC) (const char *) myCols[i].Name, nColName+1, &nColName, 0);
} else {
myCols[i].Name.Grow(1);
*(myCols[i].Name.GetBuffer()) = '\0';
}
}
SQLColAttribute(*myHSTMT, i+1, SQL_DESC_DISPLAY_SIZE, 0, 0, 0,
&myCols[i].DispSize);
myColMap.Set(myCols[i].Name,&myCols[i]);
if (myCols[i].DispSize > DEFAULT_MAX_BUFFER) {
myCols[i].DispSize = DEFAULT_MAX_BUFFER;
}
nAlloc += (myCols[i].DispSize + 1);
}
SQLINTEGER rowSetSize = max((long unsigned int) 1, (dbLib->GetMaxBuffer() / (nAlloc + (myColN * sizeof(SQLINTEGER)))));
nResult = SQLSetStmtAttr(*myHSTMT, SQL_ATTR_ROW_ARRAY_SIZE, (void *) rowSetSize, SQL_IS_INTEGER);
nResult = SQLGetStmtAttr(*myHSTMT, SQL_ATTR_ROW_ARRAY_SIZE, &rowSetSize, SQL_IS_INTEGER, NULL);
nResult = SQLSetStmtAttr(*myHSTMT, SQL_ATTR_ROWS_FETCHED_PTR, &myRowsetSize, SQL_IS_POINTER);
myRowsetMax = myRowsetSize = rowSetSize;
myRow = 0;
myBufIndex = 0;
myMem = (char *) malloc(nAlloc * (myRowsetSize+1) + sizeof(SQLINTEGER) * (myColN+1) * (myRowsetSize+1));
char *pB = myMem;
long *pI = (long *) (myMem + nAlloc * (myRowsetSize+1));
for(i = 0; i < myColN; i++) {
myCols[i].SetBuf(pB);
myCols[i].SetIndPtr(pI);
myCols[i].SetStmt(this);
SQLBindCol(*myHSTMT, (UWORD)(i+1), SQL_C_CHAR, myCols[i].GetBuf(), myCols[i].DispSize + 1, &myCols[i].GetInd());
pB += (myCols[i].DispSize + 1) * myRowsetSize;
pI += myRowsetSize;
}
myBufIndex = myRowsetSize;
return true;
}
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;
}
//
// dump descriptors
//
void dumpDescriptors (SQLCHAR *comment, // display heading/comment
SQLHSTMT hstmt, // statement handle
USHORT header, // display header record
USHORT records, // display col/parm records
int incBookmarkRec) { // include bookmark record
SQLRETURN retcode;
SQLHDESC hArd, hIrd, hApd, hIpd; // descriptors
// Get ARD
retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hArd, 0, NULL);
CHECK_ERROR(retcode, "SQLGetStmtAttr(SQL_HANDLE_STMT)",
hstmt, SQL_HANDLE_STMT);
// Get IRD
retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hIrd, 0, NULL);
CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
hstmt, SQL_HANDLE_STMT);
// Get APD
retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hApd, 0, NULL);
CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
hstmt, SQL_HANDLE_STMT);
// Get IPD
retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_PARAM_DESC, &hIpd, 0, NULL);
CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
hstmt, SQL_HANDLE_STMT);
printf ("\n---\n%s\n---\n", comment);
dumpDescriptorRec ("ARD", hArd, incBookmarkRec);
if (header=='Y') {
dumpDescriptorHeaderFields (hArd);
}
if (records=='Y') {
dumpDescriptorRecordFields (hArd, incBookmarkRec);
}
dumpDescriptorRec ("IRD", hIrd, incBookmarkRec);
if (header=='Y') {
dumpDescriptorHeaderFields (hIrd);
}
if (records='Y') {
dumpDescriptorRecordFields (hIrd, incBookmarkRec);
}
dumpDescriptorRec ("APD", hApd, incBookmarkRec);
if (header=='Y') {
dumpDescriptorHeaderFields (hApd);
}
if (records='Y') {
dumpDescriptorRecordFields (hApd, incBookmarkRec);
}
dumpDescriptorRec ("IPD", hIpd, incBookmarkRec);
if (header=='Y') {
dumpDescriptorHeaderFields (hIpd);
}
if (records='Y') {
dumpDescriptorRecordFields (hIpd, incBookmarkRec);
}
exit:
return;
}
