ODBCColumn::ODBCColumn(const SQLHSTMT hdl_stmt, const int i_col)
{
column_name[0] = '\0';
buffer_len = sizeof(column_name);
name_length = 0;
sql_data_type = 0;
c_data_type = 0;
column_size = 0;
decimal_digits = 0;
nullable = 0;
// retrieve column information from odbc
if (!SQL_SUCCEEDED(
SQLDescribeCol(hdl_stmt, i_col, column_name, buffer_len, &name_length,
&sql_data_type, &column_size, &decimal_digits, &nullable))) {
ODBCContext::extract_error(SQL_HANDLE_STMT, hdl_stmt);
raise_warning("unable to retrieve column information.");
}
// figure out the best c data type based on the sql data type we have
c_data_type = SQL_C_CHAR;
switch (sql_data_type) {
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_TINYINT:
case SQL_BIGINT:
c_data_type = SQL_C_LONG;
break;
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
c_data_type = SQL_C_DOUBLE;
break;
case SQL_CHAR:
case SQL_VARCHAR:
// TODO: we're returning timestamps as strings
case SQL_TYPE_TIMESTAMP:
default:
c_data_type = SQL_C_CHAR;
break;
}
}
bool CDataBase::Exec(const char * szQuery)
{
bool bReturn = false;
// ----
Clear(); // #ShadowKing : clean the cursor before use it
// ----
m_Return = SQLExecDirect(m_hStmt, (SQLCHAR *)szQuery, SQL_NTS);
// ----
OnQuery(szQuery);
// ----
if((m_Return == SQL_SUCCESS) || (m_Return == SQL_SUCCESS_WITH_INFO) || (m_Return == SQL_NO_DATA))
{
SQLRowCount(m_hStmt, & m_AfftedRowCount);
SQLNumResultCols(m_hStmt, & m_nCol);
// ----
if (m_nCol > MAXCOL)
{
OnError("You have exceeded the maximum number of columns");
}
else if(m_nCol == 0)
{
Clear();
// ----
bReturn = true;
}
else
{
for (int i = 0 ; i < m_nCol ; i++)
{
SQLBindCol(m_hStmt, i+1, SQL_C_CHAR, m_Col[i], 255, & m_lCol[i]);
SQLDescribeCol(m_hStmt, i+1, m_ColName[i], 30, NULL, NULL, NULL, NULL, NULL);
}
// ----
bReturn = true;
}
}
else
{
Diagnostic();
}
// ----
return bReturn;
}
void ODBCHandler::ExecuteQuery(const char *sql, QVariantList &list, int *ok)
{
SQLHSTMT stmt;
SQLRETURN ret;
SQLRETURN ret2;
SQLSMALLINT columns; /* number of columns in result-set */
QVariantMap rMap;
int row = 0;
if (ODBC_env != SQL_NULL_HANDLE || connected != 0)
{
if(odbc_execute_query(&stmt,sql))
{
/* How many columns are there */
SQLNumResultCols(stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
ColDesc c;
printf("Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
SQLCHAR buf[512];
//get column info
ret2 = SQLDescribeCol(stmt,i,c.colName, sizeof(c.colName), &c.nameLen,NULL, NULL, NULL, NULL);
/* retrieve column data as a string */
ret = SQLGetData(stmt, i, SQL_C_CHAR,buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret) && SQL_SUCCEEDED(ret2)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy((char*)buf, "NULL");
//printf(" Column %s %u : %s\n", c.colName,i, buf);
rMap.insert(QString( reinterpret_cast<char*>(c.colName)),QString( reinterpret_cast<char*>(buf)));
}
}
list.push_back(rMap);
}
}else{
//TODO:validate on error
}
}
}
SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec_string(switch_odbc_handle_t *handle, const char *sql, char *resbuf, size_t len, char **err)
{
#ifdef SWITCH_HAVE_ODBC
switch_odbc_status_t sstatus = SWITCH_ODBC_FAIL;
switch_odbc_statement_handle_t stmt = NULL;
SQLCHAR name[1024];
SQLLEN m = 0;
handle->affected_rows = 0;
if (switch_odbc_handle_exec(handle, sql, &stmt, err) == SWITCH_ODBC_SUCCESS) {
SQLSMALLINT NameLength, DataType, DecimalDigits, Nullable;
SQLULEN ColumnSize;
int result;
SQLRowCount(stmt, &m);
handle->affected_rows = (int) m;
if (m == 0) {
goto done;
}
result = SQLFetch(stmt);
if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO && result != SQL_NO_DATA) {
goto done;
}
SQLDescribeCol(stmt, 1, name, sizeof(name), &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable);
SQLGetData(stmt, 1, SQL_C_CHAR, (SQLCHAR *) resbuf, (SQLLEN) len, NULL);
sstatus = SWITCH_ODBC_SUCCESS;
}
done:
switch_odbc_statement_handle_free(&stmt);
return sstatus;
#else
return SWITCH_ODBC_FAIL;
#endif
}
void ODBCHandler::testQuery(const char *query)
{
SQLHSTMT stmt;
SQLRETURN ret;
SQLRETURN ret2;
SQLSMALLINT columns; /* number of columns in result-set */
int row = 0;
if (ODBC_env != SQL_NULL_HANDLE || connected != 0)
{
if(odbc_execute_query(&stmt,query))
{
/* How many columns are there */
SQLNumResultCols(stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
ColDesc c;
printf("Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
SQLCHAR buf[512];
/* retrieve column data as a string */
ret2 = SQLDescribeCol(stmt,i,
c.colName, sizeof(c.colName), &c.nameLen,
&c.dataType, &c.colSize, &c.decimalDigits, &c.nullable);
ret = SQLGetData(stmt, i, SQL_C_CHAR,buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy((char*)buf, "NULL");
printf(" Column %s %u : %s\n", c.colName,i, buf);
}
}
}
}else{
}
}
}
BYTE* CODBC::ReadScorcoData(char* SQL, char *param, BOOL* pSqlError, int *size)
{
SQLSMALLINT NumCols;
SQLUINTEGER columnSizePtr;
if (strcmp(param, "FETCHMODE") != 0)
{
SQLFreeStmt(hstmt,SQL_CLOSE);
// execute the query
rc=SQLExecDirect(hstmt, (unsigned char *)SQL, SQL_NTS);
if (!MYSQLSUCCESS(rc))
{
SaveSQLError();
*pSqlError = true;
return NULL;
}
}
*pSqlError = false;
// walk through the resultset
if (SQLFetch(hstmt) != SQL_SUCCESS)
return NULL;
SQLNumResultCols(hstmt, &NumCols);
if (NumCols == 1)
{
SQLDescribeCol(hstmt, 1, NULL, 0, NULL, NULL, &columnSizePtr, NULL, NULL);
if (columnSizePtr > MAXRESULT)
{
sprintf(lastError, "Critical error - object too large (>%ld bytes).\n", MAXRESULT);
*pSqlError = true;
return NULL;
}
SQLGetData(hstmt, 1, SQL_C_BINARY, pReturn, columnSizePtr, &cbData);
*size = columnSizePtr;
return pReturn;
}
else
return NULL;
}
SQLRETURN SQL_API
SQLDescribeColA(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLCHAR *ColumnName,
SQLSMALLINT BufferLength,
SQLSMALLINT *NameLengthPtr,
SQLSMALLINT *DataTypePtr,
SQLULEN *ColumnSizePtr,
SQLSMALLINT *DecimalDigitsPtr,
SQLSMALLINT *NullablePtr)
{
return SQLDescribeCol(StatementHandle,
ColumnNumber,
ColumnName,
BufferLength,
NameLengthPtr,
DataTypePtr,
ColumnSizePtr,
DecimalDigitsPtr,
NullablePtr);
}
int CODBCRecordset::GetFieldIndex(CHAR *szFieldName)
{
SQLSMALLINT nCols;
int nCol = 1;
CHAR szColName[MAX_COL_NAME_LEN];
SQLSMALLINT cbColNameLen, fSqlType, ibScale, fNullable;
SQLULEN cbColDef;
SQLNumResultCols(m_hStmt, &nCols);
while(nCol < nCols)
{
memset(szColName, 0, 32 * sizeof(CHAR));
SQLDescribeCol(m_hStmt, nCol, (SQLCHAR*)szColName, MAX_COL_NAME_LEN, &cbColNameLen, &fSqlType, &cbColDef, &ibScale, &fNullable);
if(_stricmp(szColName, szFieldName) == 0)
return nCol - 1;
nCol++;
}
return -1;
}
/*
* Class: org_jboss_odbc_OdbcClient
* Method: getColMetadata
* Signature: (ILorg/jboss/odbc/OdbcClient/ColumnMetadata;)V
*/
JNIEXPORT jobject JNICALL Java_org_jboss_odbc_OdbcClient_getColMetadata(JNIEnv *jnienv, jobject obj, jint col) {
int h = getStaticHandle(jnienv, obj);
SQLSMALLINT nameLength, dataType, decimalDigits, nullable;
SQLULEN colSize;
jstring jstr;
char name[512];
SQLDescribeCol(stmt[h], (SQLUSMALLINT) col, name, sizeof(name), &nameLength, &dataType, &colSize, &decimalDigits, &nullable);
jstr = (*jnienv)->NewStringUTF(jnienv, name);
jclass clazz;
jmethodID cid;
jobject meta;
clazz = (*jnienv)->FindClass(jnienv, "org/jboss/odbc/OdbcClient$ColumnMetadata");
cid = (*jnienv)->GetMethodID(jnienv, clazz, "<init>", "(Ljava/lang/String;IJIZ)V");
meta = (*jnienv)->NewObject(jnienv, clazz, cid, jstr, dataType, colSize, decimalDigits, (jboolean) (nullable == SQL_NULLABLE));
return meta;
}
/*
** Creates two tables with the names and the types of the columns.
*/
static void create_colinfo (lua_State *L, cur_data *cur) {
SQLCHAR buffer[256];
SQLSMALLINT namelen, datatype, i;
SQLRETURN ret;
int types, names;
lua_newtable(L);
types = lua_gettop (L);
lua_newtable(L);
names = lua_gettop (L);
for (i = 1; i <= cur->numcols; i++) {
ret = SQLDescribeCol(cur->hstmt, i, buffer, sizeof(buffer),
&namelen, &datatype, NULL, NULL, NULL);
/*if (ret == SQL_ERROR) return fail(L, hSTMT, cur->hstmt);*/
lua_pushstring (L, buffer);
lua_rawseti (L, names, i);
lua_pushstring(L, sqltypetolua(datatype));
lua_rawseti (L, types, i);
}
cur->colnames = luaL_ref (L, LUA_REGISTRYINDEX);
cur->coltypes = luaL_ref (L, LUA_REGISTRYINDEX);
}
int
QDRecordset::GetFieldIndex(const char* szFieldName)
{
int nCol = 0;
char szColName[MAX_COL_NAME_LEN];
SQLSMALLINT nCols;
SQLSMALLINT cbColNameLen, fSqlType, ibScale, fNullable;
SQLUINTEGER cbColDef;
SQLNumResultCols(m_hStmt, &nCols);
while(nCol < nCols)
{
memset(szColName, 0, MAX_COL_NAME_LEN);
SQLDescribeCol(m_hStmt, nCol+1, (SQLCHAR*)szColName, MAX_COL_NAME_LEN, &cbColNameLen, &fSqlType, &cbColDef, &ibScale, &fNullable);
if(_stricmp(szColName, szFieldName) == 0)
return nCol;
nCol++;
}
return -1;
}
void
print_result_meta_series(HSTMT hstmt,
SQLSMALLINT *colids,
SQLSMALLINT numcols)
{
int i;
printf("Result set metadata:\n");
for (i = 0; i < numcols; i++)
{
SQLRETURN rc;
SQLCHAR colname[50];
SQLSMALLINT colnamelen;
SQLSMALLINT datatype;
SQLULEN colsize;
SQLSMALLINT decdigits;
SQLSMALLINT nullable;
rc = SQLDescribeCol(hstmt, colids[i],
colname, sizeof(colname),
&colnamelen,
&datatype,
&colsize,
&decdigits,
&nullable);
if (!SQL_SUCCEEDED(rc))
{
print_diag("SQLDescribeCol failed", SQL_HANDLE_STMT, hstmt);
return;
}
printf("%s: %s(%u) digits: %d, %s\n",
colname, datatype_str(datatype), (unsigned int) colsize,
decdigits, nullable_str(nullable));
}
}
/*
---------------------------------------------------------
TestSQLTablePrivileges
---------------------------------------------------------
*/
PassFail TestMXSQLTablePrivileges( TestInfo *pTestInfo)
{
TEST_DECLARE;
char Heading[MAX_HEADING_SIZE];
/* */char ColumnWC4_TabOwner[NAME_LEN];
RETCODE returncode;
SQLHANDLE henv = (SQLHANDLE)NULL;
SQLHANDLE hdbc = (SQLHANDLE)NULL;
SQLHANDLE hstmt = (SQLHANDLE)NULL, hstmt1 = (SQLHANDLE)NULL;
CHAR TableQualifier[NAME_LEN],TableOwner[NAME_LEN],*TableStr;
CHAR *TableName;
// CHAR *Grantor; //Assume that we log on as role.user
CHAR Grantor[SQL_MAX_ROLENAME_LEN+2];
CHAR oTableQualifier[NAME_LEN];
CHAR oTableOwner[NAME_LEN];
CHAR oTableName[NAME_LEN];
CHAR oGrantor[NAME_LEN];
CHAR oGrantee[NAME_LEN];
CHAR oPrivilege[NAME_LEN];
CHAR oIs_Grantable[3];
SQLLEN oTableQualifierlen;
SQLLEN oTableOwnerlen;
SQLLEN oTableNamelen;
SQLLEN oGrantorlen = SQL_NTS;
SQLLEN oGranteelen;
SQLLEN oPrivilegelen;
SQLLEN oIs_Grantablelen;
/* */
struct
{
CHAR *Col;
CHAR *Grantee;
CHAR *Is_Grantable;
CHAR *Privilege;
} TableCol[] = {
{"--",SQ_GRANTEE,"YES","DELETE"},
{"--",SQ_GRANTEE,"NO","DELETE,SELECT"},
{"--",SQ_GRANTEE,"YES","SELECT"},
{"--",SQ_GRANTEE,"NO","DELETE"},
{"--",SQ_GRANTEE,"YES","INSERT"},
{"--",SQ_GRANTEE,"NO","UPDATE"},
{"--",SQ_GRANTEE,"YES","REFERENCES"},
{"--",SQ_GRANTEE,"NO","SELECT"},
{"--",SQ_GRANTEE,"YES","INSERT"},
{"--",SQ_GRANTEE,"NO","REFERENCES"},
{"--",SQ_GRANTEE,"YES","UPDATE"},
{"--",SQ_GRANTEE,"NO","REFERENCES"},
{"--",SQ_GRANTEE,"YES","UPDATE"},
{"--",SQ_GRANTEE,"NO","INSERT",},
{"--",SQ_GRANTEE,"YES","SELECT"},
{"--",SQ_GRANTEE,"NO","REFERENCES,SELECT"},
{"--",SQ_GRANTEE,"YES","DELETE,INSERT,SELECT"},
{"--",SQ_GRANTEE,"NO","INSERT,REFERENCES,UPDATE"},
{"--",SQ_GRANTEE,"YES","SELECT,DELETE,INSERT,UPDATE"},
{"--",SQ_GRANTEE,"NO","DELETE,INSERT,REFERENCES,UPDATE",},
{"--",SQ_GRANTEE,"YES","DELETE,INSERT,REFERENCES,SELECT,UPDATE"},
{"--",SQ_GRANTEE,"NO","DELETE"}, //Bignum
{"--",SQ_GRANTEE,"YES","SELECT"}, //Bignum
{"--",SQ_GRANTEE,"NO","INSERT"}, //Bignum
{"--",SQ_GRANTEE,"YES","UPDATE"}, //Bignum
{"--",SQ_GRANTEE,"NO","REFERENCES"}, //Bignum
{"--",SQ_GRANTEE,"YES","SELECT,DELETE,INSERT,UPDATE"},//Bignum
{"--",SQ_GRANTEE,"NO","INSERT,REFERENCES,UPDATE"}, //Bignum
{"endloop",}
};
struct
{
CHAR *TabQua;
CHAR *TabOwner;
CHAR *TabName;
RETCODE CheckCode;
int isEscape;
} ColumnWC[] = { // wild cards from here
{"--","--","--", SQL_SUCCESS,0},// Have a row with all valid values here so that
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_ERROR,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
{"--","--","--", SQL_SUCCESS,0},
// Testing escape sequences
{"--","--","--", SQL_SUCCESS,1},
{"--","--","--", SQL_SUCCESS,1},
{"--","--","--", SQL_SUCCESS,1},
{"--","--","--", SQL_SUCCESS,1},
{"endloop",}
};
struct
{
CHAR *TabQua;
SWORD TabQuaLen;
CHAR *TabOwner;
SWORD TabOwnerLen;
CHAR *TabName;
SWORD TabNameLen;
CHAR *ColName;
SWORD ColNameLen;
} ColumnWC2[] = { // wild cards from here
{"--", (SWORD)-1, "--",(SWORD)-1, "--",(SWORD)-1, "", (SWORD)-1},
{"--", (SWORD)4, "--",(SWORD)2, "--",(SWORD)2, "", (SWORD)2},
// {"TEST_CATALOG", (SWORD)0, "TEST_SCHEMA",(SWORD)0, "TEST_TABLE",(SWORD)0, "", (SWORD)0},
{"endloop",}
};
int cols;
int iatt;
SWORD numOfCols = 0;
SWORD pcbDesc;
SQLLEN pfDesc;
CHAR cn[COLNAME_LEN];
SWORD cl;
SWORD st;
SQLULEN cp;
SWORD cs, cnull;
CHAR rgbDesc[RGB_MAX_LEN];
CHAR *CharOutput[12];
SQLLEN stringlength; // Attributes for columns added for negative testing
UWORD DescrType[] =
{
SQL_COLUMN_AUTO_INCREMENT,SQL_COLUMN_CASE_SENSITIVE,SQL_COLUMN_COUNT,
SQL_COLUMN_DISPLAY_SIZE,SQL_COLUMN_LENGTH,SQL_COLUMN_MONEY,
SQL_COLUMN_NULLABLE,SQL_COLUMN_PRECISION,SQL_COLUMN_SCALE,
SQL_COLUMN_SEARCHABLE,SQL_COLUMN_TYPE,SQL_COLUMN_UNSIGNED,
SQL_COLUMN_UPDATABLE,SQL_COLUMN_NAME,SQL_COLUMN_TYPE_NAME,
SQL_COLUMN_OWNER_NAME,SQL_COLUMN_QUALIFIER_NAME,SQL_COLUMN_TABLE_NAME,
SQL_COLUMN_LABEL
};
CHAR *TestColumn;
int i = 0, k = 0;
struct {
char cat[STR_LEN];
char sch[STR_LEN];
char tab[STR_LEN];
} displayBuf;
// DWORD nSize;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars("SQLTablePrivileges", charset_file);
if (var_list == NULL) return FAILED;
TableName = var_mapping("SQLTablePrivileges_TableName", var_list);
TestColumn = var_mapping("SQLTablePrivileges_TestColumn", var_list);
TableCol[0].Col = var_mapping("SQLTablePrivileges_TableCol_Col_0", var_list);
TableCol[1].Col = var_mapping("SQLTablePrivileges_TableCol_Col_1", var_list);
TableCol[2].Col = var_mapping("SQLTablePrivileges_TableCol_Col_2", var_list);
TableCol[3].Col = var_mapping("SQLTablePrivileges_TableCol_Col_3", var_list);
TableCol[4].Col = var_mapping("SQLTablePrivileges_TableCol_Col_4", var_list);
TableCol[5].Col = var_mapping("SQLTablePrivileges_TableCol_Col_5", var_list);
TableCol[6].Col = var_mapping("SQLTablePrivileges_TableCol_Col_6", var_list);
TableCol[7].Col = var_mapping("SQLTablePrivileges_TableCol_Col_7", var_list);
TableCol[8].Col = var_mapping("SQLTablePrivileges_TableCol_Col_8", var_list);
TableCol[9].Col = var_mapping("SQLTablePrivileges_TableCol_Col_9", var_list);
TableCol[10].Col = var_mapping("SQLTablePrivileges_TableCol_Col_10", var_list);
TableCol[11].Col = var_mapping("SQLTablePrivileges_TableCol_Col_11", var_list);
TableCol[12].Col = var_mapping("SQLTablePrivileges_TableCol_Col_12", var_list);
TableCol[13].Col = var_mapping("SQLTablePrivileges_TableCol_Col_13", var_list);
TableCol[14].Col = var_mapping("SQLTablePrivileges_TableCol_Col_14", var_list);
TableCol[15].Col = var_mapping("SQLTablePrivileges_TableCol_Col_15", var_list);
TableCol[16].Col = var_mapping("SQLTablePrivileges_TableCol_Col_16", var_list);
TableCol[17].Col = var_mapping("SQLTablePrivileges_TableCol_Col_17", var_list);
TableCol[18].Col = var_mapping("SQLTablePrivileges_TableCol_Col_18", var_list);
TableCol[19].Col = var_mapping("SQLTablePrivileges_TableCol_Col_19", var_list);
TableCol[20].Col = var_mapping("SQLTablePrivileges_TableCol_Col_20", var_list);
TableCol[21].Col = var_mapping("SQLTablePrivileges_TableCol_Col_21", var_list);
TableCol[22].Col = var_mapping("SQLTablePrivileges_TableCol_Col_22", var_list);
TableCol[23].Col = var_mapping("SQLTablePrivileges_TableCol_Col_23", var_list);
TableCol[24].Col = var_mapping("SQLTablePrivileges_TableCol_Col_24", var_list);
TableCol[25].Col = var_mapping("SQLTablePrivileges_TableCol_Col_25", var_list);
TableCol[26].Col = var_mapping("SQLTablePrivileges_TableCol_Col_26", var_list);
TableCol[27].Col = var_mapping("SQLTablePrivileges_TableCol_Col_27", var_list);
ColumnWC[0].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_0", var_list);
ColumnWC[0].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_0", var_list);
ColumnWC[0].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_0", var_list);
ColumnWC[1].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_1", var_list);
ColumnWC[1].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_1", var_list);
ColumnWC[1].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_1", var_list);
ColumnWC[2].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_2", var_list);
ColumnWC[2].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_2", var_list);
ColumnWC[2].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_2", var_list);
ColumnWC[3].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_3", var_list);
ColumnWC[3].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_3", var_list);
ColumnWC[3].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_3", var_list);
ColumnWC[4].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_4", var_list);
ColumnWC[4].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_4", var_list);
ColumnWC[4].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_4", var_list);
ColumnWC[5].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_5", var_list);
ColumnWC[5].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_5", var_list);
ColumnWC[5].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_5", var_list);
ColumnWC[6].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_6", var_list);
ColumnWC[6].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_6", var_list);
ColumnWC[6].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_6", var_list);
ColumnWC[7].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_7", var_list);
ColumnWC[7].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_7", var_list);
ColumnWC[7].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_7", var_list);
ColumnWC[8].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_8", var_list);
ColumnWC[8].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_8", var_list);
ColumnWC[8].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_8", var_list);
ColumnWC[9].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_9", var_list);
ColumnWC[9].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_9", var_list);
ColumnWC[9].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_9", var_list);
ColumnWC[10].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_10", var_list);
ColumnWC[10].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_10", var_list);
ColumnWC[10].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_10", var_list);
ColumnWC[11].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_11", var_list);
ColumnWC[11].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_11", var_list);
ColumnWC[11].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_11", var_list);
ColumnWC[12].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_12", var_list);
ColumnWC[12].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_12", var_list);
ColumnWC[12].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_12", var_list);
ColumnWC[13].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_13", var_list);
ColumnWC[13].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_13", var_list);
ColumnWC[13].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_13", var_list);
ColumnWC[14].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_14", var_list);
ColumnWC[14].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_14", var_list);
ColumnWC[14].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_14", var_list);
ColumnWC[15].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_15", var_list);
ColumnWC[15].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_15", var_list);
ColumnWC[15].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_15", var_list);
ColumnWC[16].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_16", var_list);
ColumnWC[16].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_16", var_list);
ColumnWC[16].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_16", var_list);
ColumnWC[17].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_17", var_list);
ColumnWC[17].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_17", var_list);
ColumnWC[17].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_17", var_list);
ColumnWC[18].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_18", var_list);
ColumnWC[18].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_18", var_list);
ColumnWC[18].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_18", var_list);
ColumnWC[19].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_19", var_list);
ColumnWC[19].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_19", var_list);
ColumnWC[19].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_19", var_list);
ColumnWC[20].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_20", var_list);
ColumnWC[20].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_20", var_list);
ColumnWC[20].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_20", var_list);
ColumnWC[21].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_21", var_list);
ColumnWC[21].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_21", var_list);
ColumnWC[21].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_21", var_list);
ColumnWC[22].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_22", var_list);
ColumnWC[22].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_22", var_list);
ColumnWC[22].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_22", var_list);
ColumnWC[23].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_23", var_list);
ColumnWC[23].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_23", var_list);
ColumnWC[23].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_23", var_list);
ColumnWC[24].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_24", var_list);
ColumnWC[24].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_24", var_list);
ColumnWC[24].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_24", var_list);
ColumnWC[25].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_25", var_list);
ColumnWC[25].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_25", var_list);
ColumnWC[25].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_25", var_list);
ColumnWC[26].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_26", var_list);
ColumnWC[26].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_26", var_list);
ColumnWC[26].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_26", var_list);
ColumnWC[27].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_27", var_list);
ColumnWC[27].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_27", var_list);
ColumnWC[27].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_27", var_list);
ColumnWC[28].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_28", var_list);
ColumnWC[28].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_28", var_list);
ColumnWC[28].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_28", var_list);
ColumnWC[29].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_29", var_list);
ColumnWC[29].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_29", var_list);
ColumnWC[29].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_29", var_list);
ColumnWC[30].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_30", var_list);
ColumnWC[30].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_30", var_list);
ColumnWC[30].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_30", var_list);
ColumnWC[31].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_31", var_list);
ColumnWC[31].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_31", var_list);
ColumnWC[31].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_31", var_list);
ColumnWC[32].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_32", var_list);
ColumnWC[32].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_32", var_list);
ColumnWC[32].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_32", var_list);
ColumnWC[33].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_33", var_list);
ColumnWC[33].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_33", var_list);
ColumnWC[33].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_33", var_list);
ColumnWC[34].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_34", var_list);
ColumnWC[34].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_34", var_list);
ColumnWC[34].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_34", var_list);
ColumnWC2[0].TabQua = var_mapping("SQLTablePrivileges_ColumnWC2_TabQua_0", var_list);
ColumnWC2[0].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC2_TabOwner_0", var_list);
ColumnWC2[0].TabName = var_mapping("SQLTablePrivileges_ColumnWC2_TabName_0", var_list);
ColumnWC2[1].TabQua = var_mapping("SQLTablePrivileges_ColumnWC2_TabQua_1", var_list);
ColumnWC2[1].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC2_TabOwner_1", var_list);
ColumnWC2[1].TabName = var_mapping("SQLTablePrivileges_ColumnWC2_TabName_1", var_list);
//=================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => SQLTablePrivileges | SQLTablePriv | tabpriv.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLTablePrivileges tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,"Unable to connect\n");
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
#ifdef LDAP
// Grantor = var_mapping("SQLTablePrivileges_Grantor", var_list);
/*
returncode = SQLGetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_ROLENAME, (SQLCHAR*)Grantor, SQL_MAX_ROLENAME_LEN+2, (SQLINTEGER *) &oGrantorlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
*/
/* hardcode it for now */ strcpy (Grantor, "DB__ROOT");
#else
sprintf(Grantor, "%s", var_mapping("SQLTablePrivileges_Grantor", var_list));
#endif
LogMsg(NONE,"Grantor is: %s\n", Grantor);
TESTCASE_END; // end of setup
strcpy(TableQualifier,pTestInfo->Catalog);
strcpy(TableOwner,pTestInfo->Schema);
TableStr = (char *)malloc(MAX_NOS_SIZE);
i = 0;
while (_stricmp(TableCol[i].Col,"endloop") != 0)
{
sprintf(Heading,"Test #%d\n",i);
TESTCASE_BEGIN(Heading);
if (_stricmp(TableCol[i].Privilege,"ALL PRIVILEGES") == 0)
strcpy(TableCol[i].Privilege,"DELETE");
// clean up left over table, if any. We don't care about returncode from SQLExecDirect
sprintf(TableStr,"drop table %s",TableName);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
// create table to test against
sprintf(TableStr,"create table %s (%s) no partition;",TableName,TableCol[i].Col);
returncode = SQLExecDirect(hstmt,(SQLCHAR*)TableStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
// execute GRANT statement to set up some table privileges
sprintf(TableStr,"GRANT %s ON %s TO \"%s\"",TableCol[i].Privilege,TableName,TableCol[i].Grantee);
if (_stricmp(TableCol[i].Is_Grantable,"YES") == 0)
strcat(TableStr, " WITH GRANT OPTION");
LogMsg(NONE,"%s\n",TableStr);
returncode = SQLExecDirect(hstmt,(SQLCHAR*)TableStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
// Execute SQLTablePrivileges for test table
if (strlen(TableQualifier) == 0)
returncode = SQLTablePrivileges(hstmt,NULL,0,(SQLCHAR*)TableOwner,(SWORD)strlen(TableOwner),(SQLCHAR*)TableName,(SWORD)strlen(TableName));
else
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)TableQualifier,(SWORD)strlen(TableQualifier),(SQLCHAR*)TableOwner,(SWORD)strlen(TableOwner),(SQLCHAR*)TableName,(SWORD)strlen(TableName));
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
LogMsg(NONE,"SQLTablePrivileges function call executed correctly.\n");
// clear all buffers
strcpy(oTableQualifier,"");
strcpy(oTableOwner,"");
strcpy(oTableName,"");
strcpy(oGrantor,"");
strcpy(oGrantee,"");
strcpy(oPrivilege,"");
strcpy(oIs_Grantable,"");
// Bind all columns to recieve data returned from SQLTablePrivileges
returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
// Loop, reading and checking all data retuned from SQLTablePrivileges call
k = 0;
while (returncode == SQL_SUCCESS)
{
returncode = SQLFetch(hstmt);
if((returncode!=SQL_NO_DATA_FOUND) && (!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
// check for SQL_SUCCESS in case SQL_NO_DATA_FOUND was what was returned
// compare results for rows where oGrantor is not the same as Grantor (super.super)
if ((returncode == SQL_SUCCESS) && (_stricmp(Grantor,oGrantor) == 0) && (_stricmp(TableCol[i].Grantee,oGrantee) == 0))
{
k++; // found a match, increment counter
if ((_stricmp(TableQualifier,oTableQualifier) == 0)
&& (cstrcmp(TableOwner,oTableOwner,TRUE,isCharSet) == 0)
&& (cstrcmp(TableName,oTableName,TRUE,isCharSet) == 0)
//&& (_stricmp(oGrantor,Grantor) == 0)
//&& (_stricmp(TableCol[i].Grantee,oGrantee) == 0) // NOT NEEDED
&& (strstr(TableCol[i].Privilege,oPrivilege) != NULL)
&& (_stricmp(TableCol[i].Is_Grantable,oIs_Grantable) == 0) )
{
LogMsg(NONE,"SQLTablePrivileges: compare results of rows fetched for following column.\n");
LogMsg(NONE,"TableQualifier expect: %s and actual: %s are matched\n",TableQualifier,oTableQualifier);
LogMsg(NONE,"TableOwner expect: %s and actual: %s are matched\n",TableOwner,oTableOwner);
LogMsg(NONE,"TableName expect: %s and actual: %s are matched\n",TableName,oTableName);
LogMsg(NONE,"Grantor expect: %s and actual: %s are matched\n",Grantor,oGrantor);
LogMsg(NONE,"Grantee expect: %s and actual: %s are matched\n",TableCol[i].Grantee,oGrantee);
LogMsg(NONE,"Privilege expect: %s and actual: %s are matched\n",TableCol[i].Privilege,oPrivilege);
LogMsg(NONE,"Is_Grantable expect: %s and actual: %s are matched\n",TableCol[i].Is_Grantable,oIs_Grantable);
}
else
{
TEST_FAILED;
LogMsg(NONE,"SQLTablePrivileges: compare results of rows fetched for following column failed line %d.\n", __LINE__);
if (_stricmp(TableQualifier,oTableQualifier) != 0)
LogMsg(ERRMSG,"TableQualifier expect: %s and actual: %s are not matched\n",TableQualifier,oTableQualifier);
if (cstrcmp(TableOwner,oTableOwner,TRUE,isCharSet) != 0)
LogMsg(ERRMSG,"TableOwner expect: %s and actual: %s are not matched\n",TableOwner,oTableOwner);
if (cstrcmp(TableName,oTableName,TRUE,isCharSet) != 0)
LogMsg(ERRMSG,"TableName expect: %s and actual: %s are not matched\n",TableName,oTableName);
//if (_stricmp(oGrantor,Grantor) != 0)
// LogMsg(ERRMSG,"Grantor expect: %s and actual: %s are not matched\n",Grantor,oGrantor);
//if (_stricmp(TableCol[i].Grantee,oGrantee) != 0)
// LogMsg(ERRMSG,"Grantee expect: %s and actual: %s are not matched\n",TableCol[i].Grantee,oGrantee);
if (strstr(TableCol[i].Privilege,oPrivilege) == NULL)
LogMsg(ERRMSG,"Privilege expect: %s and actual: %s are not matched\n",TableCol[i].Privilege,oPrivilege);
if (_stricmp(TableCol[i].Is_Grantable,oIs_Grantable) != 0)
LogMsg(ERRMSG,"Is_Grantable expect: %s and actual: %s are not matched\n",TableCol[i].Is_Grantable,oIs_Grantable);
}
}
}
}
if(k == 0){
TEST_FAILED;
LogMsg(ERRMSG,"No matching grantee record for '%s' found\n"
" At least one row fetched should have matched\n",
TableCol[i].Grantee);
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
}
}
}
TESTCASE_END;
// clean up SQL table
sprintf(TableStr,"drop table %s",TableName);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
i++;
}
//=======================================================================================
i = 0;
sprintf(TableStr,"drop table %s.%s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
LogMsg(NONE,"%s\n",TableStr);
sprintf(TableStr,"drop schema %s.%s cascade",ColumnWC[i].TabQua, ColumnWC[i].TabOwner);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
LogMsg(NONE,"%s\n",TableStr);
sprintf(TableStr,"create schema %s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner);
LogMsg(NONE,"%s\n",TableStr);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
sprintf(TableStr,"create table %s.%s.%s(%s char(10)) no partition;",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName, TestColumn);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
LogMsg(NONE,"%s\n",TableStr);
returncode = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,(SQLPOINTER)SQL_FALSE,0);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}// end of setup
if (returncode == SQL_SUCCESS)
{
while ((_stricmp(ColumnWC[i].TabQua,"endloop") != 0) && (ColumnWC[i].isEscape == 0))
{
sprintf(Heading,"SQLTablePrivileges: wildcard options => \n"
"Table Qualifier: %s \nTable Owner: %s \nTable Name: %s\n",
printSymbol(ColumnWC[i].TabQua,displayBuf.cat),
printSymbol(ColumnWC[i].TabOwner,displayBuf.sch),
printSymbol(ColumnWC[i].TabName,displayBuf.tab));
TESTCASE_BEGIN(Heading);
if (_stricmp(ColumnWC[i].TabQua,"NULL") == 0)
ColumnWC[i].TabQua = NULL;
if (_stricmp(ColumnWC[i].TabOwner,"NULL") == 0)
ColumnWC[i].TabOwner = NULL;
if (_stricmp(ColumnWC[i].TabName,"NULL") == 0)
ColumnWC[i].TabName = NULL;
if (ColumnWC[i].TabQua == NULL || ColumnWC[i].TabOwner == NULL || ColumnWC[i].TabName == NULL)
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,SQL_NTS,
(SQLCHAR*)ColumnWC[i].TabOwner,SQL_NTS,
(SQLCHAR*)removeQuotes(ColumnWC[i].TabName,displayBuf.tab),SQL_NTS);
else
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),
(SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner),
(SQLCHAR*)removeQuotes(ColumnWC[i].TabName,displayBuf.tab),(SWORD)strlen(displayBuf.tab));
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
else
{
LogMsg(NONE,"SQLTablePrivileges: SQLTablePrivileges function call executed correctly.\n");
strcpy(oTableQualifier,"");
strcpy(oTableOwner,"");
strcpy(oTableName,"");
strcpy(oGrantor,"");
strcpy(oGrantee,"");
strcpy(oPrivilege,"");
strcpy(oIs_Grantable,"");
returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
k = 0;
while (returncode == SQL_SUCCESS)
{
returncode = SQLFetch(hstmt);
if((returncode!=SQL_NO_DATA_FOUND) && (!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
if (returncode == SQL_SUCCESS)
k++;
}
if(k == 0 && ColumnWC[i].CheckCode == SQL_SUCCESS)
{
if(ColumnWC[i].isEscape == 1)
LogMsg(ERRMSG, "Search string pattern in Catalog's Name is not supported\n");
else {
TEST_FAILED;
LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n");
}
}
}
SQLFreeStmt(hstmt,SQL_CLOSE);
TESTCASE_END;
i++;
}
}
//======================================================================================================
TESTCASE_BEGIN("SQLTablePrivileges: Negative test with invalid handle.\n");
i = 0;
returncode = SQLTablePrivileges(hstmt1,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),(SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner),(SQLCHAR*)ColumnWC[i].TabName,(SWORD)strlen(ColumnWC[i].TabName));
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLTables"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//=========================================================================================
TESTCASE_BEGIN("SQLTables: Negative test with NULL handle.\n");
hstmt1 = (SQLHANDLE)NULL;
i = 0;
returncode = SQLTablePrivileges(hstmt1,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),(SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner),(SQLCHAR*)ColumnWC[i].TabName,(SWORD)strlen(ColumnWC[i].TabName));
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLTables"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//=========================================================================================
TESTCASE_BEGIN("SQLTablePrivileges: Negative test with invalid arg lengths.\n");
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC2[0].TabQua,ColumnWC2[0].TabQuaLen,(SQLCHAR*)ColumnWC2[0].TabOwner,ColumnWC2[0].TabOwnerLen,(SQLCHAR*)ColumnWC2[0].TabName,ColumnWC2[0].TabNameLen);
LogMsg(NONE, "Input parameters: CatalogLen %d SchemaLen %d TableLen %d\n", ColumnWC2[0].TabQuaLen, ColumnWC2[0].TabOwnerLen, ColumnWC2[0].TabNameLen);
if(!CHECKRC(SQL_ERROR,returncode,"SQLTablePrivileges"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//=========================================================================================
TESTCASE_BEGIN("SQLTablePrivileges: Positive test with invalid arg lengths.\n");
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC2[1].TabQua,ColumnWC2[1].TabQuaLen,(SQLCHAR*)ColumnWC2[1].TabOwner,ColumnWC2[1].TabOwnerLen,(SQLCHAR*)ColumnWC2[1].TabName,ColumnWC2[1].TabNameLen);
LogMsg(NONE, "Input parameters: CatalogLen %d SchemaLen %d TableLen %d\n", ColumnWC2[1].TabQuaLen, ColumnWC2[1].TabOwnerLen, ColumnWC2[1].TabNameLen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
else {
LogMsg(NONE,"SQLTablePrivileges: SQLTablePrivileges function call executed correctly.\n");
strcpy(oTableQualifier,"");
strcpy(oTableOwner,"");
strcpy(oTableName,"");
strcpy(oGrantor,"");
strcpy(oGrantee,"");
strcpy(oPrivilege,"");
strcpy(oIs_Grantable,"");
returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
k = 0;
while (returncode == SQL_SUCCESS)
{
returncode = SQLFetch(hstmt);
if (returncode == SQL_SUCCESS) k++;
}
if(k > 0)
{
TEST_FAILED;
LogMsg(ERRMSG,"Should be no data found - check for similar objects unintentionally appear\n");
}
}
TESTCASE_END;
//=========================================================================================
TESTCASE_BEGIN("Testing SQLColAttribute, SQLDescribeCol, SQLBindCol and SQLFetch functions for catalog names.\n");
returncode = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,(SQLPOINTER)SQL_FALSE,0);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}// end of setup
for(i = 0; i < 5; i++)
{
sprintf(Heading,"======================================\n"
"SQLTablePrivileges: wildcard options => \n"
"Table Qualifier: %s \nTable Owner: %s \nTable Name: %s\n",
printSymbol(ColumnWC[i].TabQua,displayBuf.cat),
printSymbol(ColumnWC[i].TabOwner,displayBuf.sch),
printSymbol(ColumnWC[i].TabName,displayBuf.tab));
LogMsg(NONE,Heading);
returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),
(SQLCHAR*)removeQuotes(ColumnWC[i].TabOwner, displayBuf.sch),(SWORD)strlen(displayBuf.sch),
(SQLCHAR*)removeQuotes(ColumnWC[i].TabName, displayBuf.tab),(SWORD)strlen(displayBuf.tab));
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLColumns"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
LogMsg(NONE,"after the call\n");
returncode = SQLNumResultCols(hstmt, &numOfCols);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultsCol"))
{
TEST_FAILED;
LogMsg(ERRMSG,"Test failed while executing call for SQLNUMRESULTSCOL");
LogAllErrors(henv,hdbc,hstmt);
}
for(cols = 0; cols < numOfCols; cols++)
{
returncode = SQLDescribeCol(hstmt,(SWORD)(cols+1),(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol"))
{
TEST_FAILED;
LogMsg(ERRMSG,"Test failed while executing call for SQLDESCRIBECOL of column");
LogAllErrors(henv,hdbc,hstmt);
}
CharOutput[cols] = (char *)malloc(STR_LEN);
for (iatt = 0; iatt <= TOTALATTRIBS; iatt++)
{
strcpy(rgbDesc,"");
pcbDesc = 0;
pfDesc = 0;
returncode = SQLColAttributes(hstmt,(SWORD)(cols+1),DescrType[iatt],rgbDesc,STR_LEN,&pcbDesc,&pfDesc);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLColAttribute"))
{
TEST_FAILED;
LogMsg(ERRMSG,"Test failed while executing call for SQLCOLATTRIBUTES of column : %d.\n",i+1);
LogAllErrors(henv,hdbc,hstmt);
}
}
returncode = SQLBindCol(hstmt,(SWORD)(cols+1),SQL_C_CHAR,CharOutput[cols],STR_LEN,&stringlength);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
TEST_FAILED;
LogMsg(ERRMSG,"Test failed while executing call for SQLBindCols of column : %d.\n",cols);
LogAllErrors(henv,hdbc,hstmt);
}
}
k = 0;
while (returncode == SQL_SUCCESS)
{
returncode = SQLFetch(hstmt);
if(returncode == SQL_ERROR)
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
} else if (returncode == SQL_NO_DATA_FOUND) {
break;
}
else {
if (returncode == SQL_SUCCESS_WITH_INFO)
LogAllErrors(henv,hdbc,hstmt);
k++;
}
}
if(k == 0)
{
TEST_FAILED;
LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n");
}
for(cols = 0; cols < numOfCols; cols++)
{
free(CharOutput[cols]);
}
TESTCASE_END;
}
//=========================================================================================
// Cleanup
i=0;
sprintf(TableStr,"drop table %s.%s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
sprintf(TableStr,"drop schema %s.%s cascade",ColumnWC[i].TabQua, ColumnWC[i].TabOwner);
SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS);
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLTablePrivileges.\n");
free(TableStr);
free_list(var_list);
TEST_RETURN;
}
/*************************************************************************
* f_sql_exec( int handle, string statement )
*
* executes an SQL statement
*************************************************************************/
svalue_t *
f_sql_exec( svalue_t * argv, int argc )
{
#if ODBC_DEBUG & DEBUG_FUNC
printf( "call f_sql_exec( )\n" );
#endif
int id, i;
SQLCHAR * statement;
hDBC * handle;
//SQLSMALLINT cols;
SQLRETURN ret;
TYPE_TEST2( argv, T_STRING );
statement = string_copy( argv->u.string );
free_string_svalue( argv );
argv--;
TYPE_TEST1( argv, T_NUMBER );
id = argv->u.number;
free_svalue( argv );
if ( !(handle = get_db_connection_by_id( id )) ) {
pfree( statement );
errorf( "Illegal handle for database.\n" );
return( NULL );
}
if ( handle->hStmt ) {
//printf( "freeing statement\n" );
ret = SQLFreeStmt( handle->hStmt, SQL_UNBIND );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "SQLFreeStmt( handle->hStmt, SQL_UNBIND ) = %d\n", ret );
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
return( NULL );
}
ret = SQLFreeHandle( SQL_HANDLE_STMT, handle->hStmt );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "SQLFreeHandle( SQL_HANDLE_STMT, handle->hStmt ) = %d\n", ret );
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
return( NULL );
}
}
if ( handle->columns ) {
for ( i = 0; i < handle->colcnt; ++i ) {
dispose_column_meta_data( handle->columns[ i ] );
}
pfree( handle->columns );
handle->columns = NULL;
}
//printf( "allocating statement \n" );
ret = SQLAllocHandle( SQL_HANDLE_STMT, handle->hDBCon, &handle->hStmt );
if ( !SQL_SUCCEEDED( ret ) ) {
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_DBC, handle->hDBCon ) );
return( NULL );
}
handle->colcnt = 0;
handle->rowcnt = 0;
// printf( "executing\n" );
ret = SQLExecDirect( handle->hStmt, statement, SQL_NTS );
pfree( statement );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "XXX: %s\n", extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
put_number( argv, 0 );
return( argv );
}
/* getting number of columns. */
//ret = SQLNumResultCols( handle->hStmt, &cols );
ret = SQLNumResultCols( handle->hStmt, &handle->colcnt );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
ret = SQLRowCount( handle->hStmt, &handle->rowcnt );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
//handle->colcnt = cols;
if ( handle->colcnt ) {
handle->columns = pxalloc( handle->colcnt * sizeof( COL_META_DATA* ) );
MEM_CHECK( handle->columns );
}
/* fetching meta data */
COL_META_DATA * tmp;
SQLCHAR dColname[ 100 ];
SQLSMALLINT dColnameLen;
SQLSMALLINT dType;
SQLSMALLINT dDDigits;
SQLSMALLINT dNullable;
SQLUINTEGER dColSize;
for ( i = 1; i <= handle->colcnt; ++i ) {
ret = SQLDescribeCol( handle->hStmt, i, dColname, sizeof( dColname ), &dColnameLen, &dType, &dColSize, &dDDigits, &dNullable );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
tmp = allocate_column_meta_data();
MEM_CHECK( tmp );
tmp->nr = i;
tmp->name = string_copy( dColname );
tmp->type = map_column_type( dType, dDDigits );
// printf( "[%s] dColSize=%d dDDigits=%d\n", dColname, dColSize, dDDigits );
SQLLEN len;
switch( tmp->type ) {
case T_NUMBER:
tmp->data.number_v = pxalloc( sizeof( SQL_C_LONG ) );
*tmp->data.number_v = 0;
SQLBindCol( handle->hStmt, i, SQL_C_LONG, tmp->data.number_v, 100, &len );
break;
case T_FLOAT:
tmp->data.double_v = pxalloc( sizeof( SQL_C_DOUBLE ) );
*tmp->data.double_v = 0;
SQLBindCol( handle->hStmt, i, SQL_C_DOUBLE, tmp->data.double_v, 100, &len );
break;
default:
tmp->data.string_v = pxalloc( (dColSize + 1) * sizeof( SQLCHAR ) );
SQLBindCol( handle->hStmt, i, SQL_C_CHAR, tmp->data.string_v, (dColSize + 1), &len );
}
handle->columns[ i-1 ] = tmp;
}
put_number( argv, id );
#if ODBC_DEBUG & DEBUG_FUNC
printf( "ret f_sql_exec( )\n" );
#endif
return( argv );
}
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 > 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 = SQLAllocHandle(SQL_HANDLE_DESC, hStmt, &hDesc)) != SQL_SUCCESS) {
odbc_perror(hStmt, erc, "SQLAllocHandle", "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);
}
if ((erc = SQLFreeHandle(SQL_HANDLE_DESC, hStmt)) != SQL_SUCCESS) {
odbc_perror(hStmt, erc, "SQLFreeHandle", "failed");
exit(EXIT_FAILURE);
}
}
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++) {
char *s;
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);
s = calloc(1, 1 + data[c].len);
assert(s);
memcpy(s, data[c].buffer, data[c].len);
fprintf(stdout, metadata[c].format_string, s);
free(s);
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);
}
}
EWXWEXPORT(wxDbColInf*,wxDb_GetResultColumns)(wxDb* db,int* pnumCols)
{
#ifndef wxUSE_ODBC
if (pnumCols) *pnumCols = 0;
return NULL;
#else
RETCODE retcode = 0;
HSTMT hstmt = SQL_NULL_HSTMT;
SWORD numCols = 0;
UWORD column = 0;
wxDbColInf* colInf = NULL;
if (pnumCols) *pnumCols = 0;
if (db==NULL) return NULL;
/* allocate column info's */
hstmt = db->GetHSTMT();
retcode = SQLNumResultCols(hstmt,&numCols);
if (retcode != SQL_SUCCESS) {
db->DispAllErrors(db->GetHENV(), db->GetHDBC(), hstmt);
return NULL;
}
if (numCols==0) return NULL;
colInf = new wxDbColInf[numCols+1];
if (!colInf) return NULL;
/* mark the end of the array */
wxStrcpy(colInf[numCols].tableName, wxEmptyString);
wxStrcpy(colInf[numCols].colName, wxEmptyString);
colInf[numCols].sqlDataType = 0;
/* initialize all column infos */
for( column = 0; column < numCols; column++)
{
SWORD colNameLen = 0;
SWORD typeNameLen = 0;
UDWORD colSize = 0;
/* get the column information */
retcode = SQLDescribeCol(hstmt, column+1,
#ifndef wxUSE_UNICODE
(SQLCHAR*)colInf[column].colName,
#else
(SQLWCHAR*)colInf[column].colName,
#endif
DB_MAX_COLUMN_NAME_LEN+1, &colNameLen,
&colInf[column].sqlDataType,
&colSize,
&colInf[column].decimalDigits,
&colInf[column].nullable );
#if (wxVERSION_NUMBER <= 2500)
colInf[column].columnSize = colSize;
#else /* (wxVERSION_NUMBER <= 2500) */
colInf[column].columnLength = colSize;
#endif /* (wxVERSION_NUMBER <= 2500) */
/* check for errors */
if (retcode != SQL_SUCCESS) {
db->DispAllErrors(db->GetHENV(), db->GetHDBC(), hstmt);
delete [] colInf;
return NULL;
}
#ifdef SQL_DESC_TYPE_NAME
/* try to get type name too (errors are no problem) */
SQLColAttribute( hstmt, column+1, SQL_DESC_TYPE_NAME,
colInf[column].typeName, 128+1,
&typeNameLen, NULL );
#endif
/* for compatibilty with the wxWindows GetColumns, we set the dbDataType too */
colInf[column].dbDataType = 0;
switch (colInf[column].sqlDataType)
{
#ifndef wxUSE_UNICODE
#if defined(SQL_WVARCHAR)
case SQL_WVARCHAR:
#endif
#if defined(SQL_WCHAR)
case SQL_WCHAR:
#endif
#endif
case SQL_VARCHAR:
case SQL_CHAR:
colInf[column].dbDataType = DB_DATA_TYPE_VARCHAR;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
#ifdef SQL_BIGINT
case SQL_BIGINT:
#endif
#ifdef SQL_BIT
case SQL_BIT:
#endif
colInf[column].dbDataType = DB_DATA_TYPE_INTEGER;
break;
case SQL_DOUBLE:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_FLOAT:
case SQL_REAL:
colInf[column].dbDataType = DB_DATA_TYPE_FLOAT;
break;
#ifdef SQL_DATE
case SQL_DATE:
colInf[column].dbDataType = DB_DATA_TYPE_DATE;
break;
#endif
#ifdef SQL_BINARY
case SQL_BINARY:
colInf[column].dbDataType = DB_DATA_TYPE_BLOB;
break;
#endif
#ifdef __WXDEBUG__
default:
wxString errMsg;
errMsg.Printf(wxT("SQL Data type %d currently not supported by wxWindows"), colInf[column].sqlDataType);
wxLogDebug(errMsg,wxT("ODBC DEBUG MESSAGE"));
#endif
}
} /* for columns */
if (pnumCols) *pnumCols = numCols;
return colInf;
#endif
}
/* ------------------------------------------------------------- */
PJXSQL jx_sqlOpen(PUCHAR sqlstmt , PJXNODE pSqlParms)
{
PNPMPARMLISTADDRP pParms = _NPMPARMLISTADDR();
// LONG format = (pParms->OpDescList->NbrOfParms >= 3) ? formatP : 0; // Status & result object
LONG attrParm;
LONG i;
// PJXSQL pSQL = jx_sqlNewStatement (pParms->OpDescList->NbrOfParms >= 2 ? pSqlParms :NULL);
PJXSQL pSQL = jx_sqlNewStatement (NULL);
pSQL->rc = SQLAllocStmt(pConnection->hdbc, &pSQL->hstmt);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return NULL; // we have an error
}
attrParm = SQL_TRUE;
pSQL->rc = SQLSetStmtAttr (pSQL->hstmt, SQL_ATTR_CURSOR_SCROLLABLE , &attrParm , 0);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return NULL; // we have an error
}
/*
attrParm = SQL_TRUE;
pSQL->rc = SQLSetStmtAttr (pSQL->hstmt, SQL_ATTR_EXTENDED_COL_INFO , &attrParm , 0);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return NULL; // we have an error
}
*/
attrParm = SQL_CONCUR_READ_ONLY;
pSQL->rc = SQLSetStmtAttr (pSQL->hstmt, SQL_ATTR_CONCURRENCY , &attrParm , 0);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return NULL; // we have an error
}
// run the statement in "sqlstr"
if (pParms->OpDescList->NbrOfParms >= 2 && pSqlParms ) {
UCHAR sqlTempStmt[32766];
strFormat(sqlTempStmt , sqlstmt , pSqlParms);
pSQL->sqlstmt = strdup(sqlTempStmt);
} else {
pSQL->sqlstmt = strdup(sqlstmt);
}
pSQL->rc = SQLExecDirect (pSQL->hstmt, pSQL->sqlstmt, SQL_NTS);
if (pSQL->rc != SQL_SUCCESS && pSQL->rc != SQL_NO_DATA_FOUND) {
check_error (pSQL);
return NULL; // we have an error
}
// Number of rows? .. No does not work :(
/*
SQLGetDiagField(SQL_HANDLE_STMT,pSQL->hstmt, 0 ,SQL_DIAG_ROW_COUNT,&pSQL->rowcount,0, NULL);
*/
/*
// Row count is only affected row in a "delete" or "update" ..TODO find a solution for select
pSQL->rc = SQLRowCount (pSQL->hstmt, &pSQL->rowcount);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return; // we have an error
}
*/
pSQL->rc = SQLNumResultCols (pSQL->hstmt, &pSQL->nresultcols);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return NULL; // we have an error
}
for (i = 0; i < pSQL->nresultcols; i++) {
PJXCOL pCol = &pSQL->cols[i];
SQLDescribeCol (pSQL->hstmt, i+1, pCol->colname, sizeof (pCol->colname),
&pCol->colnamelen, &pCol->coltype, &pCol->collen, &pCol->scale, &pCol->nullable);
pCol->colname[pCol->colnamelen] = '\0';
if (OFF == jx_IsTrue (pConnection->pOptions ,"uppercasecolname")) {
str2lower (pCol->colname , pCol->colname);
}
// get display label for column
/****************
pSQL->rc = SQLColAttributes (hstmt, i+1, SQL_DESC_LABEL, Label , sizeof(Label) , &len , NULL);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return; // we have an error
}
***********/
// get display length for column
SQLColAttributes (pSQL->hstmt, i+1, SQL_DESC_PRECISION, NULL, 0,NULL, &pCol->displaysize);
// set column length to max of display length, and column name
// length. Plus one byte for null terminator
// collen[i] = max(displaysize, collen[i]);
// collen[i] = max(collen[i], strlen((char *) colname) ) + 1;
// printf ("%-*.*s", collen[i], collen[i], colname);
// allocate memory to bind column
// bind columns to program vars, converting all types to CHAR
//*SQLBindCol (hstmt, i+1, SQL_C_CHAR, data[i], collen[i], &outlen[i]);
switch( pCol->coltype) {
case SQL_BLOB:
case SQL_CLOB:
// pCol->collen = pCol->displaysize * 2;
// pCol->data = (SQLCHAR *) malloc (pCol->collen);
pCol->collen = 1048576; // 1MEGABYTES
pCol->data = (SQLCHAR *) malloc (pCol->collen); // 1MEGABYTES
SQLBindCol (pSQL->hstmt, i+1, SQL_C_BINARY , pCol->data, pCol->collen, &pCol->outlen);
break;
case SQL_WCHAR:
case SQL_WVARCHAR:
case SQL_GRAPHIC:
case SQL_VARGRAPHIC:
pCol->collen = pCol->displaysize * 2;
pCol->data = (SQLCHAR *) malloc (pCol->collen);
SQLBindCol (pSQL->hstmt, i+1, pCol->coltype, pCol->data, pCol->collen, &pCol->outlen);
break;
default:
pCol->collen = pCol->displaysize + 3; // + . and , and zero term
pCol->data = (SQLCHAR *) malloc (pCol->collen);
SQLBindCol (pSQL->hstmt, i+1, SQL_C_CHAR, pCol->data, pCol->collen, &pCol->outlen);
break;
}
if (pCol->coltype >= SQL_NUMERIC && pCol->coltype <= SQL_DOUBLE) {
pCol->nodeType = JX_LITERAL;
} else {
pCol->nodeType = JX_VALUE;
}
}
return pSQL;
}
static void
DoTest(int n)
{
int res;
SQLCHAR output[256];
SQLSMALLINT colType;
SQLUINTEGER colSize;
SQLSMALLINT colScale, colNullable;
SQLINTEGER dataSize;
TIMESTAMP_STRUCT ts;
if (CommandWithResult(Statement, "select convert(datetime, '2002-12-27 18:43:21')") != SQL_SUCCESS) {
printf("Unable to execute statement\n");
CheckReturn();
exit(1);
}
res = SQLFetch(Statement);
if (res != SQL_SUCCESS && res != SQL_SUCCESS_WITH_INFO) {
printf("Unable to fetch row\n");
CheckReturn();
exit(1);
}
if (SQLDescribeCol(Statement, 1, output, sizeof(output), NULL, &colType, &colSize, &colScale, &colNullable) != SQL_SUCCESS) {
printf("Error getting data\n");
CheckReturn();
exit(1);
}
if (n == 0) {
memset(&ts, 0, sizeof(ts));
if (SQLGetData(Statement, 1, SQL_C_TIMESTAMP, &ts, sizeof(ts), &dataSize) != SQL_SUCCESS) {
printf("Unable to get data col %d\n", 1);
CheckReturn();
exit(1);
}
sprintf((char *) output, "%04d-%02d-%02d %02d:%02d:%02d", ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second);
} else {
if (SQLGetData(Statement, 1, SQL_C_CHAR, output, sizeof(output), &dataSize) != SQL_SUCCESS) {
printf("Unable to get data col %d\n", 1);
CheckReturn();
exit(1);
}
}
printf("Date returned: %s\n", output);
if (strcmp((char *) output, "2002-12-27 18:43:21") != 0) {
printf("Invalid returned date\n");
exit(1);
}
res = SQLFetch(Statement);
if (res != SQL_NO_DATA) {
printf("Unable to fetch row\n");
CheckReturn();
exit(1);
}
res = SQLCloseCursor(Statement);
if (!SQL_SUCCEEDED(res)) {
printf("Unable to close cursr\n");
CheckReturn();
exit(1);
}
}
SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_callback_exec_detailed(const char *file, const char *func, int line,
switch_odbc_handle_t *handle,
const char *sql, switch_core_db_callback_func_t callback, void *pdata,
char **err)
{
#ifdef SWITCH_HAVE_ODBC
SQLHSTMT stmt = NULL;
SQLSMALLINT c = 0, x = 0;
SQLLEN m = 0;
char *x_err = NULL, *err_str = NULL;
int result;
int err_cnt = 0;
int done = 0;
handle->affected_rows = 0;
switch_assert(callback != NULL);
if (!db_is_up(handle)) {
x_err = "DB is not up!";
goto error;
}
if (SQLAllocHandle(SQL_HANDLE_STMT, handle->con, &stmt) != SQL_SUCCESS) {
x_err = "Unable to SQL allocate handle!";
goto error;
}
if (SQLPrepare(stmt, (unsigned char *) sql, SQL_NTS) != SQL_SUCCESS) {
x_err = "Unable to prepare SQL statement!";
goto error;
}
result = SQLExecute(stmt);
if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO && result != SQL_NO_DATA) {
x_err = "execute error!";
goto error;
}
SQLNumResultCols(stmt, &c);
SQLRowCount(stmt, &m);
handle->affected_rows = (int) m;
while (!done) {
int name_len = 256;
char **names;
char **vals;
int y = 0;
result = SQLFetch(stmt);
if (result != SQL_SUCCESS) {
if (result != SQL_NO_DATA) {
err_cnt++;
}
break;
}
names = calloc(c, sizeof(*names));
vals = calloc(c, sizeof(*vals));
switch_assert(names && vals);
for (x = 1; x <= c; x++) {
SQLSMALLINT NameLength = 0, DataType = 0, DecimalDigits = 0, Nullable = 0;
SQLULEN ColumnSize = 0;
names[y] = malloc(name_len);
memset(names[y], 0, name_len);
SQLDescribeCol(stmt, x, (SQLCHAR *) names[y], (SQLSMALLINT) name_len, &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable);
if (!ColumnSize) {
ColumnSize = 255;
}
ColumnSize++;
vals[y] = malloc(ColumnSize);
memset(vals[y], 0, ColumnSize);
SQLGetData(stmt, x, SQL_C_CHAR, (SQLCHAR *) vals[y], ColumnSize, NULL);
y++;
}
if (callback(pdata, y, vals, names)) {
done = 1;
}
for (x = 0; x < y; x++) {
free(names[x]);
free(vals[x]);
}
free(names);
free(vals);
}
SQLFreeHandle(SQL_HANDLE_STMT, stmt);
stmt = NULL; /* Make sure we don't try to free this handle again */
if (!err_cnt) {
return SWITCH_ODBC_SUCCESS;
}
error:
if (stmt) {
err_str = switch_odbc_handle_get_error(handle, stmt);
}
if (zstr(err_str) && !zstr(x_err)) {
err_str = strdup(x_err);
}
if (err_str) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
if (err) {
*err = err_str;
} else {
free(err_str);
}
}
if (stmt) {
SQLFreeHandle(SQL_HANDLE_STMT, stmt);
}
#endif
return SWITCH_ODBC_FAIL;
}
/*
* Get and convert columns from a result
*/
int db_unixodbc_get_columns(const db1_con_t* _h, db1_res_t* _r)
{
int col;
SQLSMALLINT cols; /* because gcc don't like RES_COL_N */
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter\n");
return -1;
}
/* Save number of columns in the result structure */
SQLNumResultCols(CON_RESULT(_h), &cols);
RES_COL_N(_r) = cols;
if (!RES_COL_N(_r)) {
LM_ERR("no columns returned from the query\n");
return -2;
} else {
LM_DBG("%d columns returned from the query\n", RES_COL_N(_r));
}
if (db_allocate_columns(_r, RES_COL_N(_r)) != 0) {
LM_ERR("could not allocate columns\n");
return -3;
}
for(col = 0; col < RES_COL_N(_r); col++)
{
RES_NAMES(_r)[col] = (str*)pkg_malloc(sizeof(str));
if (! RES_NAMES(_r)[col]) {
LM_ERR("no private memory left\n");
db_free_columns(_r);
return -4;
}
LM_DBG("allocate %lu bytes for RES_NAMES[%d] at %p\n",
(unsigned long)sizeof(str),col, RES_NAMES(_r)[col]);
char columnname[80];
SQLRETURN ret;
SQLSMALLINT namelength, datatype, decimaldigits, nullable;
SQLULEN columnsize;
ret = SQLDescribeCol(CON_RESULT(_h), col + 1, (SQLCHAR *)columnname, 80,
&namelength, &datatype, &columnsize, &decimaldigits, &nullable);
if(!SQL_SUCCEEDED(ret)) {
LM_ERR("SQLDescribeCol failed: %d\n", ret);
db_unixodbc_extract_error("SQLExecDirect", CON_RESULT(_h), SQL_HANDLE_STMT,
NULL);
// FIXME should we fail here completly?
}
/* The pointer that is here returned is part of the result structure. */
RES_NAMES(_r)[col]->s = columnname;
RES_NAMES(_r)[col]->len = namelength;
LM_DBG("RES_NAMES(%p)[%d]=[%.*s]\n", RES_NAMES(_r)[col], col,
RES_NAMES(_r)[col]->len, RES_NAMES(_r)[col]->s);
switch(datatype)
{
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_TINYINT:
case SQL_DECIMAL:
case SQL_NUMERIC:
LM_DBG("use DB1_INT result type\n");
RES_TYPES(_r)[col] = DB1_INT;
break;
case SQL_BIGINT:
LM_DBG("use DB1_BIGINT result type\n");
RES_TYPES(_r)[col] = DB1_BIGINT;
break;
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
LM_DBG("use DB1_DOUBLE result type\n");
RES_TYPES(_r)[col] = DB1_DOUBLE;
break;
case SQL_TYPE_TIMESTAMP:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
case SQL_TYPE_DATE:
case SQL_TYPE_TIME:
LM_DBG("use DB1_DATETIME result type\n");
RES_TYPES(_r)[col] = DB1_DATETIME;
break;
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_WCHAR:
case SQL_WVARCHAR:
LM_DBG("use DB1_STRING result type\n");
RES_TYPES(_r)[col] = DB1_STRING;
break;
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_WLONGVARCHAR:
LM_DBG("use DB1_BLOB result type\n");
RES_TYPES(_r)[col] = DB1_BLOB;
break;
default:
LM_WARN("unhandled data type column (%.*s) type id (%d), "
"use DB1_STRING as default\n", RES_NAMES(_r)[col]->len,
RES_NAMES(_r)[col]->s, datatype);
RES_TYPES(_r)[col] = DB1_STRING;
break;
}
}
return 0;
}
static void WriteBodyDelimited( SQLHSTMT hStmt, char cDelimiter )
{
SQLINTEGER nCol = 0;
SQLSMALLINT nColumns = 0;
SQLLEN nIndicator = 0;
SQLCHAR szColumnValue[MAX_DATA_WIDTH+1];
SQLRETURN nReturn = 0;
SQLRETURN ret;
SQLINTEGER *types;
*szColumnValue = '\0';
if ( SQLNumResultCols( hStmt, &nColumns ) != SQL_SUCCESS )
nColumns = -1;
if ( bQuote && nColumns > 0 )
{
types = malloc( nColumns * sizeof ( SQLINTEGER ));
for ( nCol = 1; nCol <= nColumns && types; nCol++ )
{
SQLSMALLINT type = 0;
nReturn = SQLDescribeCol( hStmt, nCol, NULL, 0, NULL, &type, NULL, NULL, NULL );
switch ( type )
{
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_WCHAR:
case SQL_WVARCHAR:
case SQL_LONGVARCHAR:
case SQL_WLONGVARCHAR:
types[ nCol - 1 ] = 1;
break;
default:
types[ nCol - 1 ] = 0;
break;
}
}
}
else
{
types = NULL;
}
/* ROWS */
while (( ret = SQLFetch( hStmt )) == SQL_SUCCESS )
{
/* COLS */
for ( nCol = 1; nCol <= nColumns; nCol++ )
{
nReturn = SQLGetData( hStmt, nCol, SQL_C_CHAR, (SQLPOINTER)szColumnValue, sizeof(szColumnValue), &nIndicator );
if ( nReturn == SQL_SUCCESS && nIndicator != SQL_NULL_DATA )
{
if ( types && types[ nCol - 1 ] )
{
putchar( '"' );
}
fputs((char*) szColumnValue, stdout );
if ( types && types[ nCol - 1 ] )
{
putchar( '"' );
}
if ( nCol < nColumns )
{
putchar( cDelimiter );
}
}
else if ( nReturn == SQL_ERROR )
{
ret = SQL_ERROR;
break;
}
else
{
if ( nCol < nColumns )
{
putchar( cDelimiter );
}
}
}
if (ret != SQL_SUCCESS)
{
break;
}
printf( "\n" );
}
if ( ret == SQL_ERROR )
{
if ( bVerbose ) DumpODBCLog( 0, 0, hStmt );
}
if ( types )
{
free( types );
}
}
static int odbc_stmt_describe(pdo_stmt_t *stmt, int colno)
{
pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
struct pdo_column_data *col = &stmt->columns[colno];
RETCODE rc;
SWORD colnamelen;
SQLULEN colsize;
SQLLEN displaysize;
rc = SQLDescribeCol(S->stmt, colno+1, S->cols[colno].colname,
sizeof(S->cols[colno].colname)-1, &colnamelen,
&S->cols[colno].coltype, &colsize, NULL, NULL);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLDescribeCol");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
rc = SQLColAttribute(S->stmt, colno+1,
SQL_DESC_DISPLAY_SIZE,
NULL, 0, NULL, &displaysize);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLColAttribute");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
colsize = displaysize;
col->maxlen = S->cols[colno].datalen = colsize;
col->namelen = colnamelen;
col->name = estrdup(S->cols[colno].colname);
S->cols[colno].is_unicode = pdo_odbc_sqltype_is_unicode(S, S->cols[colno].coltype);
/* returning data as a string */
col->param_type = PDO_PARAM_STR;
/* tell ODBC to put it straight into our buffer, but only if it
* isn't "long" data, and only if we haven't already bound a long
* column. */
if (colsize < 256 && !S->going_long) {
S->cols[colno].data = emalloc(colsize+1);
S->cols[colno].is_long = 0;
rc = SQLBindCol(S->stmt, colno+1,
S->cols[colno].is_unicode ? SQL_C_BINARY : SQL_C_CHAR,
S->cols[colno].data,
S->cols[colno].datalen+1, &S->cols[colno].fetched_len);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLBindCol");
return 0;
}
} else {
/* allocate a smaller buffer to keep around for smaller
* "long" columns */
S->cols[colno].data = emalloc(256);
S->going_long = 1;
S->cols[colno].is_long = 1;
}
return 1;
}
/*
---------------------------------------------------------
TestSQLDescribeCol for MP Specific
---------------------------------------------------------
*/
PassFail TestMXSQLDescribeCol(TestInfo *pTestInfo)
{
TEST_DECLARE;
TCHAR Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv, hdbc, hstmt;
UWORD icol;
SWORD numcol, st, cs, cnull, cl, colsize = 2;
SQLULEN cp;
TCHAR cn[COLNAME_LEN];
TCHAR *colname[COL_LEN];
TCHAR *ExecDirStr[12];
TCHAR *colVal[2];
#ifndef _WM
#ifdef UNICODE
SWORD SQLType[] = {SQL_WCHAR,SQL_WVARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,
SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_WVARCHAR,SQL_BIGINT,
SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,
SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR,SQL_CHAR,SQL_VARCHAR,SQL_WVARCHAR};
SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,19,19,128,128,10,18,30,254,254,2000,1016,1016,2000};
SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0};
#else
SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,
SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_VARCHAR,SQL_BIGINT,
SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR,
SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC };
SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30};
SWORD ColScale[]= {0, 0, 6, 6, 0,0, 0,0, 0, 0, 0,6, 0, 0, 0, 0, 0, 0, 6, 0, 128,5, 5, 10};
#endif
#else
SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,
SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_CHAR,SQL_TIME,SQL_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT,
SQL_WCHAR,SQL_WVARCHAR,SQL_WLONGVARCHAR,
SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC};
SQLULEN ColPrec[] = {254,127,18,18,5,10,7,15,15,8,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30};
SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0};
#endif
TCHAR TempType1[50],TempType2[50];
SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE};
TCHAR *TestCase[] = {
_T("before preparing stmt "),
_T("before preparing & executing stmt "),
_T("before preparing, executing & fetching stmt "),
_T("before execdirect stmt "),
_T("before execdirect & fetching stmt "),
_T("before preparing param stmt "),
_T("before preparing & binding stmt "),
_T("before preparing, binding & executing stmt "),
_T("before preparing, binding, executing & fetching stmt ")
};
int lend = 9, iend = 3;
SQLUSMALLINT i = 0, l = 0;
SQLLEN cbIn = SQL_NTS;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLDescribeColumns"), charset_file);
if (var_list == NULL) return FAILED;
//print_list(var_list);
colname[0] = var_mapping(_T("SQLDescribeColumns_colname_1"), var_list);
colname[1] = var_mapping(_T("SQLDescribeColumns_colname_2"), var_list);
colname[2] = var_mapping(_T("SQLDescribeColumns_colname_3"), var_list);
colname[3] = var_mapping(_T("SQLDescribeColumns_colname_4"), var_list);
colname[4] = var_mapping(_T("SQLDescribeColumns_colname_5"), var_list);
colname[5] = var_mapping(_T("SQLDescribeColumns_colname_6"), var_list);
colname[6] = var_mapping(_T("SQLDescribeColumns_colname_7"), var_list);
colname[7] = var_mapping(_T("SQLDescribeColumns_colname_8"), var_list);
colname[8] = var_mapping(_T("SQLDescribeColumns_colname_9"), var_list);
colname[9] = var_mapping(_T("SQLDescribeColumns_colname_10"), var_list);
colname[10] = var_mapping(_T("SQLDescribeColumns_colname_11"), var_list);
colname[11] = var_mapping(_T("SQLDescribeColumns_colname_12"), var_list);
colname[12] = var_mapping(_T("SQLDescribeColumns_colname_13"), var_list);
colname[13] = var_mapping(_T("SQLDescribeColumns_colname_14"), var_list);
colname[14] = var_mapping(_T("SQLDescribeColumns_colname_15"), var_list);
colname[15] = var_mapping(_T("SQLDescribeColumns_colname_16"), var_list);
colname[16] = var_mapping(_T("SQLDescribeColumns_colname_17"), var_list);
colname[17] = var_mapping(_T("SQLDescribeColumns_colname_18"), var_list);
colname[18] = var_mapping(_T("SQLDescribeColumns_colname_19"), var_list);
colname[19] = var_mapping(_T("SQLDescribeColumns_colname_20"), var_list);
colname[20] = var_mapping(_T("SQLDescribeColumns_colname_21"), var_list);
colname[21] = var_mapping(_T("SQLDescribeColumns_colname_22"), var_list);
colname[22] = var_mapping(_T("SQLDescribeColumns_colname_23"), var_list);
colname[23] = var_mapping(_T("SQLDescribeColumns_colname_24"), var_list);
#ifdef UNICODE
colname[24] = var_mapping(_T("SQLDescribeColumns_colname_25"), var_list);
colname[25] = var_mapping(_T("SQLDescribeColumns_colname_26"), var_list);
colname[26] = var_mapping(_T("SQLDescribeColumns_colname_27"), var_list);
#endif
ExecDirStr[0] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_1"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_2"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_3"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_4"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_5"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_6"), var_list);
ExecDirStr[6] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_7"), var_list);
ExecDirStr[7] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_8"), var_list);
ExecDirStr[8] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_9"), var_list);
ExecDirStr[9] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_10"), var_list);
ExecDirStr[10] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_11"), var_list);
ExecDirStr[11] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_12"), var_list);
colVal[0] = var_mapping(_T("SQLDescribeColumns_colVal_1"), var_list);
colVal[1] = var_mapping(_T("SQLDescribeColumns_colVal_2"), var_list);
//===========================================================================================================
//if(isUCS2) {
// LogMsg(NONE,_T("Setup for UCS2 mode testing: ColPrec has to be doubled\n"));
// l = sizeof(SQLType)/sizeof(SQLType[0]);
// while(i < l) {
// if(SQLType[i] == SQL_WCHAR) {
// SQLType[i] = SQL_WCHAR;
// //ColPrec[i] *= 2; --> This is in character, so no need to double
// }
// else if (SQLType[i] == SQL_WVARCHAR) {
// SQLType[i] = SQL_WVARCHAR;
// //ColPrec[i] *= 2; --> This is in character, so no need to double
// }
// else if (SQLType[i] == SQL_WLONGVARCHAR) {
// SQLType[i] = SQL_WLONGVARCHAR;
// //ColPrec[i] *= 2; --> This is in character, so no need to double
// }
// else {
// }
// i++;
// }
// i = 0;
// l = 0;
//}
//===========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLDescribeColumns.\n"));
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLDescribCol tests\n");
if(!FullConnect(pTestInfo))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END; // end of setup
for (l = 0; l < lend; l++)
{
for (i = 0; i < iend; i++)
{
//==================================================================================
_stprintf(Heading,_T("SQLDescribeCol: Test #%d.%d\n"),l,i);
TESTCASE_BEGINW(Heading);
if ((i != (iend-1)) && (l < 5))
{
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]);
LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]);
switch( l )
{
case 0:
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 1 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 2 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
case 3 :
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 4 :
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
}
if (returncode == SQL_SUCCESS)
{
returncode=SQLNumResultCols(hstmt, &numcol);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
for (icol = 1; icol <= numcol; icol++)
{
LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol);
returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
colsize=_tcslen(colname[icol-1]);
if(isCharSet == TRUE)
colsize -= 2;
if ((cwcscmp(cn,colname[icol-1],FALSE) == 0)
&& (cl == colsize)
&& (st == SQLType[icol-1])
&& (cp == ColPrec[icol-1])
&& (cs == ColScale[icol-1])
&& (cnull == ColNullable[i]))
{
LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn);
LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl);
LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"),
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp);
LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs);
LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"),
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
else
{
TEST_FAILED;
if (cwcscmp(cn,colname[icol-1],FALSE) != 0)
LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched line %d\n"),colname[icol-1],cn,__LINE__);
if (cl != colsize)
LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched line %d\n"),colsize,cl,__LINE__);
if (st != SQLType[icol-1])
LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched line %d\n"),
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__);
if (cp != ColPrec[icol-1])
LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched line %d\n"),ColPrec[icol-1],cp,__LINE__);
if (cs != ColScale[icol-1])
LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched line %d\n"),ColScale[icol-1],cs,__LINE__);
if (cnull != ColNullable[i])
LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched line %d\n\n"),
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__);
}
} /* end icol loop */
}
else
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */
}
}
}
else if ((i == (iend-1)) && (l >= 5))
{
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]);
LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]);
switch( l )
{
case 5 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 6 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 7 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 8 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
}
if (returncode == SQL_SUCCESS)
{
SQLNumResultCols(hstmt, &numcol);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
for (icol = 1; icol <= numcol; icol++)
{
LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol);
returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
colsize=_tcslen(colname[icol-1]);
if(isCharSet == TRUE)
colsize -= 2;
if ((cwcscmp(cn,colname[icol-1],FALSE) == 0)
&& (cl == colsize)
&& (st == SQLType[icol-1])
&& (cp == ColPrec[icol-1])
&& (cs == ColScale[icol-1])
&& (cnull == ColNullable[i]))
{
LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn);
LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl);
LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"),
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp);
LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs);
LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"),
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
else
{
TEST_FAILED;
if (cwcscmp(cn,colname[icol-1],FALSE) != 0)
LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched at line %d\n"),colname[icol-1],cn,__LINE__);
if (cl != colsize)
LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched at line %d\n"),colsize,cl,__LINE__);
if (st != SQLType[icol-1])
LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched at line %d\n"),
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__);
if (cp != ColPrec[icol-1])
LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched at line %d\n"),ColPrec[icol-1],cp,__LINE__);
if (cs != ColScale[icol-1])
LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched at line %d\n"),ColScale[icol-1],cs,__LINE__);
if (cnull != ColNullable[i])
LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched at line %d\n\n"),
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__);
}
}
}
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS);
}
}
TESTCASE_END;
} /* iend loop */
} /* lend loop */
FullDisconnect(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLDescribeColumns.\n"));
free_list(var_list);
TEST_RETURN;
}
bool CMssqlRecordset::Init(CMssqlConnection *parent, HSTMT hStmt, const char *command)
{
m_bEof = false;
m_parent = parent;
m_hStmt = hStmt;
m_parent->m_lasterror=SQLExecDirect(m_hStmt,(SQLWCHAR*)(const wchar_t *)cvs::wide(command),SQL_NTS);
CServerIo::trace(1,"MSSQL Execute Done");
if((!SQL_SUCCEEDED(m_parent->m_lasterror))&&(m_parent->m_lasterror!=SQL_NEED_DATA))
{
GetStmtError();
return false;
}
if(m_parent->m_lasterror==SQL_NEED_DATA)
{
SQLPOINTER pParmID;
SQLRETURN retcode=SQL_SUCCESS, putret;
char *dataptr, *dataput;
SQLINTEGER dataoff, datasiz;
SQLINTEGER chunk=1024;
CServerIo::trace(1,"MSSQL Execute requires more data");
retcode = SQLParamData(m_hStmt, &pParmID);
if (retcode == SQL_NEED_DATA)
{
for(std::map<int,CSqlVariant>::iterator i = parent->m_bindVars.begin(); i!=parent->m_bindVars.end(); ++i)
{
switch(i->second.type())
{
case CSqlVariant::vtString:
if (parent->m_sqlv[i->first].ws.length()+1<256)
CServerIo::trace(1,"MSSQL Execute this parameter is too small to be a BLOB");
else
{
//dataput = (char *)((const char *)parent->m_sqlv[i->first].cs.c_str());
//dataoff=0; datasiz = (SQLINTEGER)(parent->m_sqlv[i->first].cs.size()+1);
dataput = (char *)((const char *)parent->m_sqlv[i->first].ws.c_str());
dataoff=0;
datasiz = (SQLINTEGER)(parent->m_sqlv[i->first].ws.size()+1);
//CServerIo::trace(1,"MSSQL Needs data - so put the data %d, size %d",(int)i->first,(int)parent->m_sqlv[i->first].cs.size()+1);
CServerIo::trace(1,"MSSQL Needs data - so put the data %d, size %d",(int)i->first,(int)parent->m_sqlv[i->first].ws.size()+1);
for (dataptr=dataput; dataoff<datasiz; dataoff+=chunk)
{
CServerIo::trace(1,"MSSQL put data %d offset %d bytes N\"%0.25s...%0.25s\"",dataoff,
(dataoff+chunk>datasiz)?datasiz-dataoff:chunk,
(const char *)cvs::narrow((const wchar_t *)(dataptr+dataoff)),
((const char *)cvs::narrow((const wchar_t *)(dataptr+dataoff))+(((dataoff+chunk>datasiz)?datasiz-dataoff:chunk)+1-25)));
putret=SQLPutData(m_hStmt, (SQLPOINTER)(dataptr+(sizeof(wchar_t)*dataoff)), (dataoff+chunk>datasiz)?(sizeof(wchar_t)*(datasiz-dataoff)):(sizeof(wchar_t)*chunk));
if(!SQL_SUCCEEDED(putret))
{
m_parent->m_lasterror = putret;
GetStmtError();
return false;
}
/*switch (putret)
{
case SQL_SUCCESS:
CServerIo::trace(1,"SQL Put Data returned SQL_SUCCESS");
break;
case SQL_SUCCESS_WITH_INFO:
CServerIo::trace(1,"SQL Put Data returned SQL_SUCCESS_WITH_INFO");
break;
case SQL_STILL_EXECUTING:
CServerIo::trace(1,"SQL Put Data returned SQL_STILL_EXECUTING");
break;
case SQL_ERROR:
CServerIo::trace(1,"SQL Put Data returned SQL_ERROR");
break;
case SQL_INVALID_HANDLE:
CServerIo::trace(1,"SQL Put Data returned SQL_INVALID_HANDLE");
break;
default:
CServerIo::trace(1,"SQL Put Data returned some other error.");
}*/
}
CServerIo::trace(1,"MSSQL call ParamData again");
retcode = SQLParamData(m_hStmt, &pParmID);
if (retcode==SQL_SUCCESS)
CServerIo::trace(1,"MSSQL call ParamData returned OK - no more data");
else if (retcode==SQL_NEED_DATA)
CServerIo::trace(1,"MSSQL call ParamData returned need more data");
}
break;
default:
break;
}
}
} else {
retcode=SQL_SUCCESS;
}
if (retcode==SQL_SUCCESS)
CServerIo::trace(1,"MSSQL call ParamData returned OK - no more data");
else if (retcode==SQL_NEED_DATA)
CServerIo::trace(1,"MSSQL call ParamData returned need more data");
else if(!SQL_SUCCEEDED(retcode))
{
CServerIo::trace(1,"MSSQL call ParamData returned some sort of failure so returning...");
m_parent->m_lasterror = retcode;
GetStmtError();
return false;
}
}
CServerIo::trace(1,"MSSQL Execute all complete now get the Number of Result Columns");
if(!SQL_SUCCEEDED(m_parent->m_lasterror = SQLNumResultCols(m_hStmt,&m_num_fields)))
{
GetStmtError();
return false;
}
m_sqlfields.resize(m_num_fields);
for(SQLSMALLINT n=0; n<m_num_fields; n++)
{
SQLRETURN rc;
SQLWCHAR szCol[128];
SQLSMALLINT len = sizeof(szCol);
rc = m_parent->m_lasterror = SQLDescribeCol(hStmt,n+1,szCol,sizeof(szCol),&len,&m_sqlfields[n].type,&m_sqlfields[n].size,&m_sqlfields[n].decimal,&m_sqlfields[n].null);
if(!SQL_SUCCEEDED(rc))
{
GetStmtError();
return false;
}
szCol[len]='\0';
m_sqlfields[n].field = n;
m_sqlfields[n].hStmt = m_hStmt;
m_sqlfields[n].name = szCol;
SQLINTEGER fldlen = 0;
SQLSMALLINT ctype;
switch(m_sqlfields[n].type)
{
case SQL_UNKNOWN_TYPE:
CServerIo::trace(1,"Unable to bind column %s as it is SQL_UNKNOWN_TYPE",(const char *)szCol);
break; // Don't bind
case SQL_CHAR:
case SQL_VARCHAR:
ctype = SQL_C_WCHAR;
fldlen = m_sqlfields[n].size;
break;
case SQL_DECIMAL:
ctype = SQL_C_WCHAR;
fldlen = m_sqlfields[n].size + m_sqlfields[n].decimal + 1;
break;
case SQL_NUMERIC:
case SQL_INTEGER:
case SQL_SMALLINT:
ctype = SQL_C_LONG;
fldlen = sizeof(long);
break;
case SQL_FLOAT:
case SQL_REAL:
case SQL_DOUBLE:
ctype = SQL_C_DOUBLE;
fldlen = sizeof(double);
break;
case SQL_DATETIME:
ctype = SQL_C_WCHAR;
fldlen = 64;
break;
}
m_sqlfields[n].ctype = ctype;
m_sqlfields[n].fldlen = fldlen;
if(m_sqlfields[n].fldlen)
{
m_sqlfields[n].data = malloc(m_sqlfields[n].fldlen);
if(!SQL_SUCCEEDED(m_parent->m_lasterror = SQLBindCol(m_hStmt,n+1,m_sqlfields[n].ctype,m_sqlfields[n].data,m_sqlfields[n].fldlen,&m_sqlfields[n].datalen)))
{
GetStmtError();
CServerIo::trace(1,"Unable to bind column %s due to error",(const char*)szCol);
return false;
}
}
}
if(m_num_fields)
{
if(!Next() && !m_bEof)
return false;
}
return true;
}
SQLRETURN unixodbc_backend::do_describe_column(SQLHSTMT statement_handle, SQLUSMALLINT column_number, SQLCHAR * column_name, SQLSMALLINT buffer_length, SQLSMALLINT * name_length, SQLSMALLINT * data_type, SQLULEN * column_size, SQLSMALLINT * decimal_digits, SQLSMALLINT * nullable) const
{
return SQLDescribeCol(statement_handle, column_number, column_name, buffer_length, name_length, data_type, column_size, decimal_digits, nullable);
}
RETCODE
backsql_BindRowAsStrings( SQLHSTMT sth, BACKSQL_ROW_NTS *row )
{
RETCODE rc;
SQLCHAR colname[ 64 ];
SQLSMALLINT name_len, col_type, col_scale, col_null;
UDWORD col_prec;
int i;
if ( row == NULL ) {
return SQL_ERROR;
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "==> backsql_BindRowAsStrings()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
rc = SQLNumResultCols( sth, &row->ncols );
if ( rc != SQL_SUCCESS ) {
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings(): "
"SQLNumResultCols() failed:\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC, sth, rc );
} else {
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"ncols=%d\n", (int)row->ncols, 0, 0 );
#endif /* BACKSQL_TRACE */
row->col_names = (BerVarray)ch_calloc( row->ncols + 1,
sizeof( struct berval ) );
row->cols = (char **)ch_calloc( row->ncols + 1,
sizeof( char * ) );
row->col_prec = (UDWORD *)ch_calloc( row->ncols,
sizeof( UDWORD ) );
row->value_len = (SQLINTEGER *)ch_calloc( row->ncols,
sizeof( SQLINTEGER ) );
for ( i = 1; i <= row->ncols; i++ ) {
rc = SQLDescribeCol( sth, (SQLSMALLINT)i, &colname[ 0 ],
(SQLUINTEGER)( sizeof( colname ) - 1 ),
&name_len, &col_type,
&col_prec, &col_scale, &col_null );
ber_str2bv( colname, 0, 1, &row->col_names[ i - 1 ] );
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"col_name=%s, col_prec[%d]=%d\n",
colname, (int)i, (int)col_prec );
#endif /* BACKSQL_TRACE */
if ( col_type == SQL_LONGVARCHAR
|| col_type == SQL_LONGVARBINARY) {
#if 0
row->cols[ i - 1 ] = NULL;
row->col_prec[ i - 1 ] = -1;
/*
* such fields must be handled
* in some other way since they return 2G
* as their precision (at least it does so
* with MS SQL Server w/native driver)
* for now, we just set fixed precision
* for such fields - dirty hack, but...
* no time to deal with SQLGetData()
*/
#endif
col_prec = MAX_ATTR_LEN;
row->cols[ i - 1 ] = (char *)ch_calloc( col_prec + 1, sizeof( char ) );
row->col_prec[ i - 1 ] = col_prec;
rc = SQLBindCol( sth, (SQLUSMALLINT)i,
SQL_C_CHAR,
(SQLPOINTER)row->cols[ i - 1 ],
col_prec + 1,
&row->value_len[ i - 1 ] );
} else {
row->cols[ i - 1 ] = (char *)ch_calloc( col_prec + 1, sizeof( char ) );
row->col_prec[ i - 1 ] = col_prec;
rc = SQLBindCol( sth, (SQLUSMALLINT)i,
SQL_C_CHAR,
(SQLPOINTER)row->cols[ i - 1 ],
col_prec + 1,
&row->value_len[ i - 1 ] );
}
}
row->col_names[ i - 1 ].bv_val = NULL;
row->col_names[ i - 1 ].bv_len = 0;
row->cols[ i - 1 ] = NULL;
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "<== backsql_BindRowAsStrings()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
return rc;
}
/*
* success = statement:execute(...)
*/
static int statement_execute(lua_State *L) {
statement_t *statement = (statement_t *)luaL_checkudata(L, 1, DBD_DB2_STATEMENT);
int n = lua_gettop(L);
int p;
int i;
int errflag = 0;
const char *errstr = NULL;
SQLRETURN rc = SQL_SUCCESS;
unsigned char *buffer = NULL;
int offset = 0;
resultset_t *resultset = NULL;
bindparams_t *bind; /* variable to read the results */
SQLSMALLINT num_params;
SQLCHAR message[SQL_MAX_MESSAGE_LENGTH + 1];
SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1];
SQLINTEGER sqlcode;
SQLSMALLINT length;
if (!statement->stmt) {
lua_pushboolean(L, 0);
lua_pushstring(L, DBI_ERR_EXECUTE_INVALID);
return 2;
}
rc = SQLNumParams(statement->stmt, &num_params);
if (rc != SQL_SUCCESS) {
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushboolean(L, 0);
lua_pushfstring(L, DBI_ERR_PREP_STATEMENT, message);
return 2;
}
if (num_params != n-1) {
/*
* SQLExecute does not handle this condition,
* and the client library will fill unset params
* with NULLs
*/
lua_pushboolean(L, 0);
lua_pushfstring(L, DBI_ERR_PARAM_MISCOUNT, num_params, n-1);
return 2;
}
if (num_params > 0) {
buffer = (unsigned char *)malloc(sizeof(double) * num_params);
}
for (p = 2; p <= n; p++) {
int i = p - 1;
int type = lua_type(L, p);
char err[64];
const char *str = NULL;
size_t len = 0;
double *num;
int *boolean;
const static SQLLEN nullvalue = SQL_NULL_DATA;
switch(type) {
case LUA_TNIL:
rc = SQLBindParameter(statement->stmt, i, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, (SQLPOINTER)0, 0, (SQLPOINTER)&nullvalue);
errflag = rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO;
break;
case LUA_TNUMBER:
num = (double *)(buffer + offset);
*num = lua_tonumber(L, p);
offset += sizeof(double);
rc = SQLBindParameter(statement->stmt, i, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DECIMAL, 10, 0, (SQLPOINTER)num, 0, NULL);
errflag = rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO;
break;
case LUA_TSTRING:
str = lua_tolstring(L, p, &len);
rc = SQLBindParameter(statement->stmt, i, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, len, NULL);
errflag = rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO;
break;
case LUA_TBOOLEAN:
boolean = (int *)(buffer + offset);
*boolean = lua_toboolean(L, p);
offset += sizeof(int);
rc = SQLBindParameter(statement->stmt, i, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, (SQLPOINTER)boolean, len, NULL);
errflag = rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO;
break;
default:
/*
* Unknown/unsupported value type
*/
errflag = 1;
snprintf(err, sizeof(err)-1, DBI_ERR_BINDING_TYPE_ERR, lua_typename(L, type));
errstr = err;
}
if (errflag)
break;
}
if (errflag) {
if (buffer)
free(buffer);
lua_pushboolean(L, 0);
if (errstr) {
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, errstr);
} else {
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, message);
}
return 2;
}
rc = SQLExecute(statement->stmt);
if (rc != SQL_SUCCESS) {
if (buffer)
free(buffer);
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushnil(L);
lua_pushfstring(L, DBI_ERR_PREP_STATEMENT, message);
return 2;
}
/*
* identify the number of output columns
*/
rc = SQLNumResultCols(statement->stmt, &statement->num_result_columns);
if (statement->num_result_columns > 0) {
resultset = (resultset_t *)malloc(sizeof(resultset_t) * statement->num_result_columns);
memset(resultset, 0, sizeof(resultset_t) * statement->num_result_columns);
bind = (bindparams_t *)malloc(sizeof(bindparams_t) * statement->num_result_columns);
memset(bind, 0, sizeof(bindparams_t) * statement->num_result_columns);
for (i = 0; i < statement->num_result_columns; i++) {
/*
* return a set of attributes for a column
*/
rc = SQLDescribeCol(statement->stmt,
(SQLSMALLINT)(i + 1),
resultset[i].name,
sizeof(resultset[i].name),
&resultset[i].name_len,
&resultset[i].type,
&resultset[i].size,
&resultset[i].scale,
NULL);
if (rc != SQL_SUCCESS) {
if (buffer)
free(buffer);
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushnil(L);
lua_pushfstring(L, DBI_ERR_DESC_RESULT, message);
return 2;
}
bind[i].buffer_len = resultset[i].size+1;
/*
*allocate memory to bind a column
*/
bind[i].buffer = (SQLCHAR *)malloc((int)bind[i].buffer_len);
rc = SQLBindCol(statement->stmt,
(SQLSMALLINT)(i + 1),
SQL_C_CHAR,
bind[i].buffer,
bind[i].buffer_len,
&bind[i].len);
if (rc != SQL_SUCCESS) {
if (buffer)
free(buffer);
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushnil(L);
lua_pushfstring(L, DBI_ERR_ALLOC_RESULT, message);
return 2;
}
}
statement->resultset = resultset;
statement->bind = bind;
}
if (buffer)
free(buffer);
lua_pushboolean(L, 1);
return 1;
}
RETCODE
backsql_BindRowAsStrings_x( SQLHSTMT sth, BACKSQL_ROW_NTS *row, void *ctx )
{
RETCODE rc;
if ( row == NULL ) {
return SQL_ERROR;
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "==> backsql_BindRowAsStrings()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
rc = SQLNumResultCols( sth, &row->ncols );
if ( rc != SQL_SUCCESS ) {
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings(): "
"SQLNumResultCols() failed:\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC, sth, rc );
} else {
SQLCHAR colname[ 64 ];
SQLSMALLINT name_len, col_type, col_scale, col_null;
UDWORD col_prec;
int i;
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"ncols=%d\n", (int)row->ncols, 0, 0 );
#endif /* BACKSQL_TRACE */
row->col_names = (BerVarray)ber_memcalloc_x( row->ncols + 1,
sizeof( struct berval ), ctx );
if ( row->col_names == NULL ) {
goto nomem;
}
row->col_prec = (UDWORD *)ber_memcalloc_x( row->ncols,
sizeof( UDWORD ), ctx );
if ( row->col_prec == NULL ) {
goto nomem;
}
row->col_type = (SQLSMALLINT *)ber_memcalloc_x( row->ncols,
sizeof( SQLSMALLINT ), ctx );
if ( row->col_type == NULL ) {
goto nomem;
}
row->cols = (char **)ber_memcalloc_x( row->ncols + 1,
sizeof( char * ), ctx );
if ( row->cols == NULL ) {
goto nomem;
}
row->value_len = (SQLINTEGER *)ber_memcalloc_x( row->ncols,
sizeof( SQLINTEGER ), ctx );
if ( row->value_len == NULL ) {
goto nomem;
}
if ( 0 ) {
nomem:
ber_memfree_x( row->col_names, ctx );
row->col_names = NULL;
ber_memfree_x( row->col_prec, ctx );
row->col_prec = NULL;
ber_memfree_x( row->col_type, ctx );
row->col_type = NULL;
ber_memfree_x( row->cols, ctx );
row->cols = NULL;
ber_memfree_x( row->value_len, ctx );
row->value_len = NULL;
Debug( LDAP_DEBUG_ANY, "backsql_BindRowAsStrings: "
"out of memory\n", 0, 0, 0 );
return LDAP_NO_MEMORY;
}
for ( i = 0; i < row->ncols; i++ ) {
SQLSMALLINT TargetType;
rc = SQLDescribeCol( sth, (SQLSMALLINT)(i + 1), &colname[ 0 ],
(SQLUINTEGER)( sizeof( colname ) - 1 ),
&name_len, &col_type,
&col_prec, &col_scale, &col_null );
/* FIXME: test rc? */
ber_str2bv_x( (char *)colname, 0, 1,
&row->col_names[ i ], ctx );
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"col_name=%s, col_prec[%d]=%d\n",
colname, (int)(i + 1), (int)col_prec );
#endif /* BACKSQL_TRACE */
if ( col_type != SQL_CHAR && col_type != SQL_VARCHAR )
{
col_prec = MAX_ATTR_LEN;
}
row->cols[ i ] = (char *)ber_memcalloc_x( col_prec + 1,
sizeof( char ), ctx );
row->col_prec[ i ] = col_prec;
row->col_type[ i ] = col_type;
/*
* ITS#3386, ITS#3113 - 20070308
* Note: there are many differences between various DPMS and ODBC
* Systems; some support SQL_C_BLOB, SQL_C_BLOB_LOCATOR. YMMV:
* This has only been tested on Linux/MySQL/UnixODBC
* For BINARY-type Fields (BLOB, etc), read the data as BINARY
*/
if ( BACKSQL_IS_BINARY( col_type ) ) {
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"col_name=%s, col_type[%d]=%d: reading binary data\n",
colname, (int)(i + 1), (int)col_type);
#endif /* BACKSQL_TRACE */
TargetType = SQL_C_BINARY;
} else {
/* Otherwise read it as Character data */
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
"col_name=%s, col_type[%d]=%d: reading character data\n",
colname, (int)(i + 1), (int)col_type);
#endif /* BACKSQL_TRACE */
TargetType = SQL_C_CHAR;
}
rc = SQLBindCol( sth, (SQLUSMALLINT)(i + 1),
TargetType,
(SQLPOINTER)row->cols[ i ],
col_prec + 1,
&row->value_len[ i ] );
/* FIXME: test rc? */
}
BER_BVZERO( &row->col_names[ i ] );
row->cols[ i ] = NULL;
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "<== backsql_BindRowAsStrings()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
return rc;
}
/*
* Test program to run on the connected database
*/
int
ODBC_Test ()
{
SQLTCHAR request[4096];
SQLTCHAR fetchBuffer[1024];
char buf[4096];
size_t displayWidths[MAXCOLS];
size_t displayWidth;
short numCols;
short colNum;
SQLTCHAR colName[50];
SQLSMALLINT colType;
SQLULEN colPrecision;
SQLLEN colIndicator;
SQLSMALLINT colScale;
SQLSMALLINT colNullable;
unsigned long totalRows;
unsigned long totalSets;
int i;
SQLRETURN sts;
while (1)
{
/*
* Ask the user for a dynamic SQL statement
*/
printf ("\nSQL>");
if (fgets (buf, sizeof (buf), stdin) == NULL)
break;
#ifndef UNICODE
strcpy ((char *) request, (char *) buf);
#else
strcpy_A2W (request, buf);
#endif
request[TXTLEN (request) - 1] = TEXTC ('\0');
if (request[0] == TEXTC ('\0'))
continue;
/*
* If the user just types tables, give him a list
*/
if (!TXTCMP (request, TEXT ("tables")))
{
if (SQLTables (hstmt, NULL, 0, NULL, 0, NULL, 0,
NULL, 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(tables)");
continue;
}
}
/*
* If the user just types qualifiers, give him a list
*/
else if (!TXTCMP (request, TEXT ("qualifiers")))
{
if (SQLTables (hstmt, TEXT ("%"), SQL_NTS, TEXT (""), 0,
TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(qualifiers)");
continue;
}
}
/*
* If the user just types owners, give him a list
*/
else if (!TXTCMP (request, TEXT ("owners")))
{
if (SQLTables (hstmt, TEXT (""), 0, TEXT ("%"), SQL_NTS,
TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(owners)");
continue;
}
}
/*
* If the user just types "types", give him a list
*/
else if (!TXTCMP (request, TEXT ("types")))
{
if (SQLTables (hstmt, TEXT (""), 0, TEXT (""), 0,
TEXT (""), 0, TEXT ("%"), SQL_NTS) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(types)");
continue;
}
}
/*
* If the user just types "datatypes", give him a list
*/
else if (!TXTCMP (request, TEXT ("datatypes")))
{
if (SQLGetTypeInfo (hstmt, 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLGetTypeInfo");
continue;
}
}
else if (!TXTCMP (request, TEXT ("reconnect")))
{
if (ODBC_Reconnect())
return -1;
continue;
}
#if defined (unix)
else if (!TXTCMP (request, TEXT ("environment")))
{
extern char **environ;
int i;
for (i = 0; environ[i]; i++)
fprintf (stderr, "%03d: [%s]\n", i, environ[i]);
continue;
}
#endif
else if (!TXTCMP (request, TEXT ("quit"))
|| !TXTCMP (request, TEXT ("exit")))
break; /* If you want to quit, just say so */
else
{
/*
* Prepare & Execute the statement
*/
if (SQLPrepare (hstmt, (SQLTCHAR *) request,
SQL_NTS) != SQL_SUCCESS)
{
ODBC_Errors ("SQLPrepare");
continue;
}
if ((sts = SQLExecute (hstmt)) != SQL_SUCCESS)
{
ODBC_Errors ("SQLExec");
if (sts != SQL_SUCCESS_WITH_INFO)
continue;
}
}
/*
* Loop through all the result sets
*/
totalSets = 1;
do
{
/*
* Get the number of result columns for this cursor.
* If it is 0, then the statement was probably a select
*/
if (SQLNumResultCols (hstmt, &numCols) != SQL_SUCCESS)
{
ODBC_Errors ("SQLNumResultCols");
goto endCursor;
}
if (numCols == 0)
{
SQLLEN nrows = 0;
SQLRowCount (hstmt, &nrows);
printf ("Statement executed. %ld rows affected.\n",
nrows > 0 ? (long) nrows : 0L);
goto endCursor;
}
if (numCols > MAXCOLS)
{
numCols = MAXCOLS;
fprintf (stderr,
"NOTE: Resultset truncated to %d columns.\n", MAXCOLS);
}
/*
* Get the names for the columns
*/
putchar ('\n');
for (colNum = 1; colNum <= numCols; colNum++)
{
/*
* Get the name and other type information
*/
if (SQLDescribeCol (hstmt, colNum,
(SQLTCHAR *) colName, NUMTCHAR (colName), NULL,
&colType, &colPrecision, &colScale,
&colNullable) != SQL_SUCCESS)
{
ODBC_Errors ("SQLDescribeCol");
goto endCursor;
}
/*
* Calculate the display width for the column
*/
switch (colType)
{
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_WVARCHAR:
case SQL_WCHAR:
case SQL_GUID:
displayWidth = colPrecision;
break;
case SQL_BINARY:
displayWidth = colPrecision * 2;
break;
case SQL_LONGVARCHAR:
case SQL_WLONGVARCHAR:
case SQL_LONGVARBINARY:
displayWidth = 30; /* show only first 30 */
break;
case SQL_BIT:
displayWidth = 1;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
displayWidth = colPrecision + 1; /* sign */
break;
case SQL_DOUBLE:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_FLOAT:
case SQL_REAL:
displayWidth = colPrecision + 2; /* sign, comma */
break;
#ifdef SQL_TYPE_DATE
case SQL_TYPE_DATE:
#endif
case SQL_DATE:
displayWidth = 10;
break;
#ifdef SQL_TYPE_TIME
case SQL_TYPE_TIME:
#endif
case SQL_TIME:
displayWidth = 8;
break;
#ifdef SQL_TYPE_TIMESTAMP
case SQL_TYPE_TIMESTAMP:
#endif
case SQL_TIMESTAMP:
displayWidth = 19;
if (colScale > 0)
displayWidth = displayWidth + colScale + 1;
break;
default:
displayWidths[colNum - 1] = 0; /* skip other data types */
continue;
}
if (displayWidth < TXTLEN (colName))
displayWidth = TXTLEN (colName);
if (displayWidth > NUMTCHAR (fetchBuffer) - 1)
displayWidth = NUMTCHAR (fetchBuffer) - 1;
displayWidths[colNum - 1] = displayWidth;
/*
* Print header field
*/
#ifdef UNICODE
printf ("%-*.*S", displayWidth, displayWidth, colName);
#else
printf ("%-*.*s", displayWidth, displayWidth, colName);
#endif
if (colNum < numCols)
putchar ('|');
}
putchar ('\n');
/*
* Print second line
*/
for (colNum = 1; colNum <= numCols; colNum++)
{
for (i = 0; i < displayWidths[colNum - 1]; i++)
putchar ('-');
if (colNum < numCols)
putchar ('+');
}
putchar ('\n');
/*
* Print all the fields
*/
totalRows = 0;
while (1)
{
#if (ODBCVER < 0x0300)
int sts = SQLFetch (hstmt);
#else
int sts = SQLFetchScroll (hstmt, SQL_FETCH_NEXT, 1);
#endif
if (sts == SQL_NO_DATA_FOUND)
break;
if (sts != SQL_SUCCESS)
{
ODBC_Errors ("Fetch");
break;
}
for (colNum = 1; colNum <= numCols; colNum++)
{
/*
* Fetch this column as character
*/
#ifdef UNICODE
sts = SQLGetData (hstmt, colNum, SQL_C_WCHAR, fetchBuffer,
NUMTCHAR (fetchBuffer), &colIndicator);
#else
sts = SQLGetData (hstmt, colNum, SQL_C_CHAR, fetchBuffer,
NUMTCHAR (fetchBuffer), &colIndicator);
#endif
if (sts != SQL_SUCCESS_WITH_INFO && sts != SQL_SUCCESS)
{
ODBC_Errors ("SQLGetData");
goto endCursor;
}
/*
* Show NULL fields as ****
*/
if (colIndicator == SQL_NULL_DATA)
{
for (i = 0; i < displayWidths[colNum - 1]; i++)
fetchBuffer[i] = TEXTC ('*');
fetchBuffer[i] = TEXTC ('\0');
}
#ifdef UNICODE
printf ("%-*.*S", displayWidths[colNum - 1],
displayWidths[colNum - 1], fetchBuffer);
#else
printf ("%-*.*s", displayWidths[colNum - 1],
displayWidths[colNum - 1], fetchBuffer);
#endif
if (colNum < numCols)
putchar ('|');
}
putchar ('\n');
totalRows++;
}
printf ("\n result set %lu returned %lu rows.\n\n",
totalSets, totalRows);
totalSets++;
}
while ((sts = SQLMoreResults (hstmt)) == SQL_SUCCESS);
if (sts == SQL_ERROR)
ODBC_Errors ("SQLMoreResults");
endCursor:
#if (ODBCVER < 0x0300)
SQLFreeStmt (hstmt, SQL_CLOSE);
#else
SQLCloseCursor (hstmt);
#endif
}
return 0;
}
/* ------------------------------------------------------------- */
LGL jx_sqlUpsert (BOOL update, PUCHAR table , PJXNODE pSqlParms , PUCHAR where)
{
LONG attrParm;
LONG i;
UCHAR sqlTempStmt[32766];
PUCHAR stmt = sqlTempStmt;
PJXNODE pNode;
PUCHAR comma = "";
PUCHAR name, value;
SQLSMALLINT length;
SQLHDBC hdbctmp;
SQLHSTMT hstmttmp;
SQLRETURN rc;
PJXSQL pSQL = jx_sqlNewStatement (NULL);
SQLCHUNK sqlChunk[32];
SHORT sqlChunkIx =0;
PUCHAR sqlNullPtr = NULL;
// First get the columen types - by now we use a select to mimic that
// allocate a statement handle
pSQL->rc = SQLAllocHandle(SQL_HANDLE_STMT, pConnection->hdbc , &hstmttmp);
if (pSQL->rc != SQL_SUCCESS ) {
SQLError( pConnection->henv, pConnection->hdbc , hstmttmp, pConnection->sqlState ,
&pConnection->sqlCode, pConnection->sqlMsgDta ,
sizeof(pConnection->sqlMsgDta), &length);
substr ( jxMessage , pConnection->sqlMsgDta , length);
return ON; // we have an error
}
stmt = sqlTempStmt;
stmt += sprintf (stmt , "select ");
comma = "";
pNode = jx_GetNode(pSqlParms, "/");
while (pNode) {
name = jx_GetNodeNamePtr (pNode);
stmt += sprintf (stmt , "%s%s" , comma , name);
comma = ",";
pNode = jx_GetNodeNext(pNode);
}
stmt += sprintf (stmt , " from %s where 1=0" , table);
// prepare the statement */
pSQL->rc = SQLPrepare(hstmttmp , sqlTempStmt, SQL_NTS);
if (pSQL->rc != SQL_SUCCESS ) {
SQLError( pConnection->henv, pConnection->hdbc , hstmttmp, pConnection->sqlState ,
&pConnection->sqlCode, pConnection->sqlMsgDta ,
sizeof(pConnection->sqlMsgDta), &length);
substr ( jxMessage , pConnection->sqlMsgDta , length);
SQLFreeStmt(hstmttmp, SQL_CLOSE);
return ON; // we have an error
}
// Now we have the colume definitions - now build the update statement:
// allocate a statement handle
pSQL->rc = SQLAllocHandle(SQL_HANDLE_STMT, pConnection->hdbc , &pSQL->hstmt);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
SQLFreeStmt(hstmttmp, SQL_CLOSE);
return ON; // we have an error
}
// This need to allow update
attrParm = SQL_INSENSITIVE;
pSQL->rc = SQLSetStmtAttr (pSQL->hstmt, SQL_ATTR_CURSOR_SENSITIVITY , &attrParm , 0);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return ON; // we have an error
}
if (update) {
buildUpdate (hstmttmp, sqlTempStmt , table, pSqlParms , where);
} else {
buildInsert (hstmttmp, sqlTempStmt , table, pSqlParms , where);
}
// prepare the statement that provides the coloumn types
pSQL->rc = SQLPrepare(pSQL->hstmt , sqlTempStmt, SQL_NTS);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
SQLFreeStmt(hstmttmp, SQL_CLOSE);
return ON; // we have an error
}
// Take the description from the "select" and use it on the "update"
pNode = jx_GetNode(pSqlParms, "/");
for (i=1; pNode; i++) {
JXCOL Col;
memset (&Col , 0 , sizeof(JXCOL));
value = jx_GetNodeValuePtr (pNode , NULL);
pSQL->rc = SQLDescribeCol (
hstmttmp,
i,
Col.colname,
sizeof (Col.colname),
&Col.colnamelen,
&Col.coltype,
&Col.collen,
&Col.scale,
&Col.nullable
);
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return ON; // we have an error
}
// bind parameter to the statement
if ( Col.coltype == SQL_BLOB
|| Col.coltype == SQL_CLOB ) {
SQLINTEGER dataAtExec = SQL_DATA_AT_EXEC;
// SQLLEN dataAtExec = SQL_LEN_DATA_AT_EXEC ( 0 );
PSQLCHUNK pSqlChunk = &sqlChunk[sqlChunkIx++];
pSqlChunk->actLen = strlen(value);
pSqlChunk->offset = 0;
pSqlChunk->chunkLen = min(pSqlChunk->actLen,16384);
pSqlChunk->value = value;
if (pSqlChunk->actLen == 0) {
pSQL->rc = SQLBindParameter(pSQL->hstmt,
i,
SQL_PARAM_INPUT,
SQL_C_BINARY, //SQL_C_CHAR, // SQL_C_BINARY, , // SQL_C_BINARY, //SQL_C_CHAR,
SQL_LONGVARBINARY, // SQL_VARBINARY, // // SQL_LONGVARCHAR,
0 , // Col.collen, // pSqlChunk->actLen, pSqlChunk->chunkLen, pSqlChunk->chunkLen,//Col.collen,
0, // presition
value, // Parm value
0 , // Buffer len - Not used
NULL // no-chunk just direct access to NULL
);
} else {
pSQL->rc = SQLBindParameter(pSQL->hstmt,
i,
SQL_PARAM_INPUT,
SQL_C_BINARY, //SQL_C_CHAR, // SQL_C_BINARY, , // SQL_C_BINARY, //SQL_C_CHAR,
SQL_LONGVARBINARY, // SQL_VARBINARY, // // SQL_LONGVARCHAR,
pSqlChunk->actLen,// Col.collen pSqlChunk->chunkLen, pSqlChunk->chunkLen,//Col.collen,//overall length
0, // presition
(SQLPOINTER) pSqlChunk, // Parm value
0 , // Buffer len - Not used
&dataAtExec // chunk size
);
}
} else {
pSQL->rc = SQLBindParameter(pSQL->hstmt,
i,
SQL_PARAM_INPUT,
SQL_C_CHAR,
Col.coltype,
Col.collen, // length
Col.scale, // presition
value,
0,
NULL // pointer to length variable
);
}
if (pSQL->rc != SQL_SUCCESS ) {
check_error (pSQL);
return ON; // we have an error
}
pNode = jx_GetNodeNext(pNode);
}
// Now we are done with the select statement:
rc = SQLFreeStmt(hstmttmp, SQL_CLOSE);
// run the statement in "sqlstr"
pSQL->rc = SQLExecute( pSQL->hstmt);
// Has BLOB's ?
while (pSQL->rc == SQL_NEED_DATA) {
SQLPOINTER parmNo;
PSQLCHUNK pSqlChunk;
SHORT i;
SQLINTEGER putLen;
PUCHAR putBuf;
pSQL->rc = SQLParamData(pSQL->hstmt, (SQLPOINTER) &pSqlChunk);
if (pSQL->rc == SQL_NEED_DATA) {
// iterate for each buffer chunk
while (pSqlChunk->actLen > 0) {
putLen = min(pSqlChunk->actLen , pSqlChunk->chunkLen);
putBuf = pSqlChunk->value + pSqlChunk->offset;
rc = SQLPutData(pSQL->hstmt, putBuf , putLen);
pSqlChunk->offset += putLen;
pSqlChunk->actLen -= putLen;
}
}
}
if (pSQL->rc != SQL_SUCCESS && pSQL->rc != SQL_NO_DATA_FOUND) {
check_error (pSQL);
return ON; // we have an error
}
jx_sqlClose (&pSQL);
return OFF;
}
