int
main(int argc, char **argv)
{
SQLRETURN rcode;
SQLHSTMT m_hstmt1;
SQLSMALLINT cnt = 0;
int failed = 0;
use_odbc_version3 = 1;
Connect();
Command(Statement, "CREATE TABLE #t1 ( k INT, c CHAR(10), vc VARCHAR(10) )");
Command(Statement, "CREATE TABLE #tmp1 (i NUMERIC(10,0) IDENTITY PRIMARY KEY, b VARCHAR(20) NULL, c INT NOT NULL)");
/* test hidden column with FOR BROWSE */
ResetStatement();
m_hstmt1 = Statement;
rcode = SQLExecDirect(m_hstmt1, (SQLCHAR *) "SELECT c, b FROM #tmp1", SQL_NTS);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLExecDirect");
rcode = SQLNumResultCols(m_hstmt1, &cnt);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLNumResultCols 1");
if (cnt != 2) {
fprintf(stderr, "Wrong number of columns in result set: %d\n", (int) cnt);
failed = 1;
}
ResetStatement();
/* test hidden column with cursors*/
CheckCursor();
m_hstmt1 = Statement;
rcode = SQLSetStmtAttr(m_hstmt1, SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER) SQL_NONSCROLLABLE, SQL_IS_UINTEGER);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLSetStmtAttr SQL_ATTR_CURSOR_SCROLLABLE");
rcode = SQLSetStmtAttr(m_hstmt1, SQL_ATTR_CURSOR_SENSITIVITY, (SQLPOINTER) SQL_SENSITIVE, SQL_IS_UINTEGER);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLSetStmtAttr SQL_ATTR_CURSOR_SENSITIVITY");
rcode = SQLPrepare(m_hstmt1, (SQLCHAR *) "SELECT * FROM #t1", SQL_NTS);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLPrepare 1");
rcode = SQLExecute(m_hstmt1);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLExecute 1");
rcode = SQLNumResultCols(m_hstmt1, &cnt);
CHECK_RCODE(SQL_HANDLE_STMT, m_hstmt1, "SQLNumResultCols 1");
if (cnt != 3) {
fprintf(stderr, "Wrong number of columns in result set: %d\n", (int) cnt);
failed = 1;
}
Disconnect();
return failed ? 1: 0;
}
CDbStmt CDbConn::Execute(const char *sql)
{
SQLHSTMT hstmt = (SQLHSTMT) NULL;
SQLRETURN nResult;
try {
if ((nResult = SQLAllocHandle(SQL_HANDLE_STMT, *myHDBC, &hstmt)) != SQL_SUCCESS) {
return CDbStmt(this, (SQLHSTMT)NULL);
}
} catch (...) {
return CDbStmt(this, (SQLHSTMT)NULL);
}
if (!sql)
return CDbStmt(this, (SQLHSTMT)NULL);
while (isspace(*sql))
++sql;
bool doStatic = false, doDynamic = false;
if (!strncmp(sql, "static", 6) && isspace(sql[6])) {
sql += 6;
doStatic = true;
} else if (!strncmp(sql, "dynamic", 7) && isspace(sql[7])) {
sql += 7;
doDynamic = true;
}
SQLSetStmtAttr(hstmt, SQL_ATTR_QUERY_TIMEOUT, (void *) myDbLib->GetTimeout(), SQL_IS_UINTEGER);
if (doStatic) {
SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_SCROLLABLE, (void *) SQL_NONSCROLLABLE, SQL_IS_UINTEGER);
SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_SENSITIVITY, (void *) SQL_INSENSITIVE, SQL_IS_UINTEGER);
}
if (doDynamic) {
SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_SCROLLABLE, (void *) SQL_SCROLLABLE, SQL_IS_UINTEGER);
SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_SENSITIVITY, (void *) SQL_SENSITIVE, SQL_IS_UINTEGER);
}
nResult = SQLExecDirect(hstmt, (LPSQLC) sql, SQL_NTS);
CDbStmt stmt(this, hstmt);
if (!SQL_SUCCEEDED(nResult) && !(nResult == SQL_NO_DATA)) {
stmt.SetError(nResult, true);
}
return stmt;
}
void ODBCStatementImpl::doPrepare()
{
if (session().getFeature("autoExtract") && hasData())
{
Poco::UInt32 curDataSet = currentDataSet();
poco_check_ptr (_preparations[curDataSet]);
Extractions& extracts = extractions();
Extractions::iterator it = extracts.begin();
Extractions::iterator itEnd = extracts.end();
if (it != itEnd && (*it)->isBulk())
{
Poco::UInt32 limit = getExtractionLimit();
if (limit == Limit::LIMIT_UNLIMITED)
throw InvalidArgumentException("Bulk operation not allowed without limit.");
checkError(SQLSetStmtAttr(_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) limit, 0),
"SQLSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE)");
}
for (std::size_t pos = 0; it != itEnd; ++it)
{
AbstractPrepare* pAP = (*it)->createPrepareObject(_preparations[curDataSet], pos);
pAP->prepare();
pos += (*it)->numOfColumnsHandled();
delete pAP;
}
_prepared = true;
}
}
/************************************************************************
* name: SQLSetStmtAttrW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLSetStmtAttrW (SQLHSTMT hstmt, SQLINTEGER attribute,
SQLPOINTER value, SQLINTEGER value_len)
{
OutputDebugString ("SQLSetStmtAttrW called.\n");
return SQLSetStmtAttr (hstmt, attribute, value, value_len);
}
SQLRETURN unixodbc_backend_debug::do_set_statement_attribute(SQLHSTMT statement_handle, SQLINTEGER attribute, SQLPOINTER value_ptr, SQLINTEGER string_length) const
{
std::cout << " *DEBUG* set_statement_attribute";
auto const return_code = SQLSetStmtAttr(statement_handle, attribute, value_ptr, string_length);
std::cout << " (return code " << return_code << ")" << std::endl;
return return_code;
}
static int odbc_dispatch3(void)
{
unsigned long retval;
PWord rval; int rtype;
PWord arg1; int type1;
PWord arg2; int type2;
PWord arg3; int type3;
PWord arg4; int type4;
PWord arg5; int type5;
PWord arg6; int type6;
PI_getan(&arg1,&type1,1);
if (type1 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg1,type1))
PI_FAIL;
PI_getan(&arg2,&type2,2);
if (type2 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg2,type2))
PI_FAIL;
PI_getan(&arg3,&type3,3);
if (type3 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg3,type3))
PI_FAIL;
PI_getan(&arg4,&type4,4);
if (type4 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg4,type4))
PI_FAIL;
PI_getan(&arg5,&type5,5);
if (type5 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg5,type5))
PI_FAIL;
PI_getan(&arg6,&type6,6);
switch(arg1)
{
case 0:
retval = (unsigned long) SQLSetScrollOptions(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLINTEGER ) arg4),((SQLUSMALLINT ) arg5));
break;
case 1:
retval = (unsigned long) SQLSetPos(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLUSMALLINT ) arg4),((SQLUSMALLINT ) arg5));
break;
case 2:
retval = (unsigned long) SQLSetStmtAttr(((SQLHSTMT ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
case 3:
retval = (unsigned long) SQLSetEnvAttr(((SQLHENV ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
case 4:
retval = (unsigned long) SQLSetConnectAttr(((SQLHDBC ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
default:
PI_FAIL;
}
PI_makedouble(&rval,&rtype,(double) retval);
if (PI_unify(arg6,type6,rval,rtype))
PI_SUCCEED;
PI_FAIL;
}
int OrderCustDetails(SQLHANDLE hdbc)
{
SQLRETURN cliRC = SQL_SUCCESS;
int rc = 0;
SQLHANDLE hstmt; /* statement handle */
SQLVARCHAR xmldata[3000];
/* query to be executed */
SQLCHAR *stmt = (SQLCHAR *)"for $custinfo in db2-fn:xmlcolumn('CUSTOMER.INFO')"
"/customerinfo[addr/@country=\"Canada\"]"
" order by $custinfo/name"
" return $custinfo";
cliRC = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
DBC_HANDLE_CHECK(hdbc, cliRC);
/* Set the attribute SQL_ATTR_XQUERY_STATEMENT to indicate that the query is an XQuery */
rc = SQLSetStmtAttr(hstmt, SQL_ATTR_XQUERY_STATEMENT, (SQLPOINTER)SQL_TRUE, SQL_NTS);
if (rc != 0)
{
return rc;
}
printf("\n Directly execute the statement\n");
printf(" %s\n", stmt);
/* directly execute the statement */
cliRC = SQLExecDirect(hstmt, stmt, SQL_NTS);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
/* bind column 1 to variable */
cliRC = SQLBindCol(hstmt, 1, SQL_C_CHAR, &xmldata, 1000, NULL);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
/* fetch each row and display */
cliRC = SQLFetch(hstmt);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
if (cliRC == SQL_NO_DATA_FOUND)
{
printf("\n Data not found.\n");
}
while (cliRC != SQL_NO_DATA_FOUND)
{
printf("%s \n\n",xmldata);
/* fetch next row */
cliRC = SQLFetch(hstmt);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
}
/* free the statement handle */
cliRC = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
return rc;
} /* OrderCustDetails */
bool DataBase::exec( const char *stmt )
{
if (0 == _hStmt)
{
SQLAllocHandle(SQL_HANDLE_STMT, _hConn, &_hStmt);
SQLSetStmtAttr(_hStmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) SQL_CURSOR_STATIC, 0);
}
RETCODE ret = SQLExecDirect(_hStmt, (SQLCHAR*)stmt, SQL_NTS);
return (ret == SQL_SUCCESS) || (ret == SQL_SUCCESS_WITH_INFO);
}
int maxpriceproduct(SQLHANDLE hdbc)
{
SQLRETURN cliRC = SQL_SUCCESS;
int rc = 0;
SQLHANDLE hstmt; /* statement handle */
SQLVARCHAR xmldata[3000];
/* query to be executed */
SQLCHAR *stmt = (SQLCHAR *)" let $prod := for $product in db2-fn:xmlcolumn('PRODUCT.DESCRIPTION')"
" /product/description"
" order by $product/price return $product"
" return <product> {$prod[1]/name} </product>";
cliRC = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
DBC_HANDLE_CHECK(hdbc, cliRC);
/* Set the attribute SQL_ATTR_XQUERY_STATEMENT to indicate that the query is an XQuery */
rc = SQLSetStmtAttr(hstmt, SQL_ATTR_XQUERY_STATEMENT, (SQLPOINTER)SQL_TRUE, SQL_NTS);
printf("%d", rc);
if (rc != 0)
{
return rc;
}
printf("\n Directly execute the statement\n");
printf(" %s\n", stmt);
/* directly execute the statement */
cliRC = SQLExecDirect(hstmt, stmt, SQL_NTS);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
/* Bind column 1 to variable */
cliRC = SQLBindCol(hstmt, 1, SQL_C_CHAR, &xmldata, 1000, NULL);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
/* Fetch each row and display */
cliRC = SQLFetch(hstmt);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
if (cliRC == SQL_NO_DATA_FOUND)
{
printf("\n Data not found.\n");
}
else
printf("%s \n\n",xmldata);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
/* free the statement handle */
cliRC = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
STMT_HANDLE_CHECK(hstmt, hdbc, cliRC);
return rc;
} /* maxpriceproduct */
K eval(K x,K y,K z){K*k;S*b,s;SQLULEN w;SQLLEN*nb;SQLINTEGER*wb;H*tb,u,t,j=0,p,m;F f;C c[128];I n=xj<0;D d=d1(n?-xj:xj);U(d)x=y;Q(z->t!=-KJ||xt!=-KS&&xt!=KC,"type")
if(z->j)SQLSetStmtAttr(d,SQL_ATTR_QUERY_TIMEOUT,(SQLPOINTER)(SQLULEN)z->j,0);
if(xt==-KS)Q1(SQLColumns(d,(S)0,0,(S)0,0,xs,S0,(S)0,0))else{I e;K q=kpn(xG,xn);ja(&q,"\0");e=SQLExecDirect(d,q->G0,xn);r0(q);Q1(e)}
SQLNumResultCols(d,&j);P(!j,(d0(d),knk(0)))
b=malloc(j*SZ),tb=malloc(j*2),wb=malloc(j*SZ),nb=malloc(j*SZ),x=ktn(KS,j),y=ktn(0,j);// sqlserver: no bind past nonbind
DO(j,Q1(SQLDescribeCol(d,(H)(i+1),c,128,&u,&t,&w,&p,&m))xS[i]=sn(c,u);
if(t>90)t-=82;
Q(t<-11||t>12,xS[i])wb[i]=ut[tb[i]=t=t>0?t:12-t]==KS&&w?w+1:wt[t];if(ut[t]==KS&&(n||!wb[i]||wb[i]>9))tb[i]=13)
DO(j,kK(y)[i]=ktn(ut[t=tb[i]],0);if(w=wb[i])Q1(SQLBindCol(d,(H)(i+1),ct[t],b[i]=malloc(w),w,nb+i)))
for(;SQL_SUCCEEDED(SQLFetch(d));)DO(j,k=kK(y)+i;u=ut[t=tb[i]];s=b[i];n=SQL_NULL_DATA==(int)nb[i];
if(!u)jk(k,n?ktn(ct[t]?KC:KG,0):wb[i]?kp(s):gb(d,(H)(i+1),t));
else ja(k,n?nu(u):u==KH&&wb[i]==1?(t=(H)*s,(S)&t):u==KS?(s=dtb(s,nb[i]),(S)&s):u<KD?s:u==KZ?(f=ds(s)+(vs(s+6)+*(I*)(s+12)/1e9)/8.64e4,(S)&f):(w=u==KD?ds(s):vs(s),(S)&w)))
if(!SQLMoreResults(d))O("more\n");DO(j,if(wb[i])free(b[i]))R free(b),free(tb),free(wb),free(nb),d0(d),xT(xD(x,y));}
bool
QDRecordset::Open(const char* szSqlStr)
{
SQLRETURN ret;
SQLSetStmtAttr(m_hStmt, SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER)SQL_SCROLLABLE, SQL_IS_INTEGER);
SQLSetStmtAttr(m_hStmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER)SQL_CURSOR_DYNAMIC, SQL_IS_INTEGER);
SQLSetStmtAttr(m_hStmt, SQL_ATTR_ROWS_FETCHED_PTR, &m_nNumRowsFetched, 0);
ret = SQLExecDirect(m_hStmt, (SQLCHAR*)szSqlStr, SQL_NTS);
if(ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
{
ret = SQLFetch(m_hStmt);
if(ret==SQL_NO_DATA_FOUND)
return FALSE;
else
return TRUE;
}
else
{
return FALSE;
}
}
void SetParameterSize(unsigned short parameterSize)
{
assert(parameterSize < MAX_PARAMETER_SIZE);
std::string message;
SQLRETURN rc = SQLSetStmtAttr(mStmt, SQL_ATTR_PARAM_STATUS_PTR, &ParamStatusArray, 0);
if (!SQL_SUCCEEDED(rc))
{
HANAException::GetHANAErrorMessage(SQL_HANDLE_STMT, mStmt, rc, message);
throw HANAException(message.c_str());
}
rc = SQLSetStmtAttr(mStmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &ParamsProcessed, 0);
if (!SQL_SUCCEEDED(rc))
{
HANAException::GetHANAErrorMessage(SQL_HANDLE_STMT, mStmt, rc, message);
throw HANAException(message.c_str());
}
rc = SQLSetStmtAttr(mStmt, SQL_ATTR_PARAM_BIND_TYPE,
(SQLPOINTER)SQL_PARAM_BIND_BY_COLUMN, 0);
if (!SQL_SUCCEEDED(rc))
{
HANAException::GetHANAErrorMessage(SQL_HANDLE_STMT, mStmt, rc, message);
throw HANAException(message.c_str());
}
rc = SQLSetStmtAttr(mStmt, SQL_ATTR_PARAMSET_SIZE,
(SQLPOINTER)parameterSize, 0);
if (!SQL_SUCCEEDED(rc))
{
HANAException::GetHANAErrorMessage(SQL_HANDLE_STMT, mStmt, rc, message);
throw HANAException(message.c_str());
}
}
int dbd_db2_statement_create(lua_State *L, connection_t *conn, const char *sql_query) {
SQLRETURN rc = SQL_SUCCESS;
statement_t *statement = NULL;
SQLHANDLE stmt;
SQLCHAR message[SQL_MAX_MESSAGE_LENGTH + 1];
SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1];
SQLINTEGER sqlcode;
SQLSMALLINT length;
rc = SQLAllocHandle(SQL_HANDLE_STMT, conn->db2, &stmt);
if (rc != SQL_SUCCESS) {
SQLGetDiagRec(SQL_HANDLE_DBC, conn->db2, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushnil(L);
lua_pushfstring(L, DBI_ERR_ALLOC_STATEMENT, message);
return 2;
}
/*
* turn off deferred prepare
* statements will be sent to the server at prepare time,
* and therefore we can catch errors now rather
* than at execute time
*/
rc = SQLSetStmtAttr(stmt,SQL_ATTR_DEFERRED_PREPARE,(SQLPOINTER)SQL_DEFERRED_PREPARE_OFF,0);
rc = SQLPrepare(stmt, (SQLCHAR *)sql_query, SQL_NTS);
if (rc != SQL_SUCCESS) {
SQLGetDiagRec(SQL_HANDLE_STMT, stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
lua_pushnil(L);
lua_pushfstring(L, DBI_ERR_PREP_STATEMENT, message);
return 2;
}
statement = (statement_t *)lua_newuserdata(L, sizeof(statement_t));
statement->stmt = stmt;
statement->db2 = conn->db2;
statement->resultset = NULL;
statement->bind = NULL;
luaL_getmetatable(L, DBD_DB2_STATEMENT);
lua_setmetatable(L, -2);
return 1;
}
EErrorType CDatabaseStatementOdbc::DoInitialise()
{
DatabaseConnectionOdbcSPtr connection = DoGetConnectionOdbc();
if ( !connection )
{
DB_EXCEPT( EDatabaseExceptionCodes_StatementError, ERROR_ODBC_LOST_CONNECTION );
}
EErrorType errorType;
HDBC hParentStmt = connection->GetHdbc();
CLogger::LogDebug( ( Format( DEBUG_ODBC_PREPARING_STATEMENT ) % this ).str() );
errorType = SqlSuccess( SQLAllocHandle( SQL_HANDLE_STMT, hParentStmt, &_statementHandle ), SQL_HANDLE_STMT, hParentStmt, INFO_ODBC_AllocHandle );
#if defined( _WIN32 )
if ( errorType == EErrorType_NONE )
{
OdbcCheck( SQLSetStmtAttr( _statementHandle, SQL_SOPT_SS_DEFER_PREPARE, SQL_DP_OFF, SQL_IS_UINTEGER ), SQL_HANDLE_STMT, _statementHandle, INFO_ODBC_SetStmtAttr );
}
#endif
if ( errorType == EErrorType_NONE )
{
OdbcCheck( SQLPrepareA( _statementHandle, ( SqlChar * )_query.c_str(), SQLINTEGER( _query.size() ) ), SQL_HANDLE_STMT, _statementHandle, INFO_ODBC_Prepare );
}
if ( errorType == EErrorType_NONE )
{
SQLSMALLINT count = 0;
OdbcCheck( SQLNumParams( _statementHandle, &count ), SQL_HANDLE_STMT, _statementHandle, INFO_ODBC_NumParams );
CLogger::LogDebug( DEBUG_ODBC_EXPECTED_PARAMETERS + StringUtils::ToString( count ) );
}
for ( auto && parameter : DoGetParameters() )
{
std::static_pointer_cast< CDatabaseStatementParameterOdbc >( parameter )->Initialise( _statementHandle );
}
return errorType;
}
void
odbc_check_cursor(void)
{
SQLRETURN retcode;
retcode = SQLSetStmtAttr(odbc_stmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
if (retcode != SQL_SUCCESS) {
char output[256];
unsigned char sqlstate[6];
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, (SQLCHAR *) output, sizeof(output), NULL, "S");
sqlstate[5] = 0;
if (strcmp((const char*) sqlstate, "01S02") == 0) {
printf("Your connection seems to not support cursors, probably you are using wrong protocol version or Sybase\n");
odbc_disconnect();
exit(0);
}
ReportODBCError("SQLSetStmtAttr", SQL_HANDLE_STMT, odbc_stmt, retcode, __LINE__, __FILE__);
}
odbc_reset_statement();
}
void
odbc_check_cursor(void)
{
SQLRETURN retcode;
ODBC_BUF *odbc_buf = NULL;
retcode = SQLSetStmtAttr(odbc_stmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
if (retcode != SQL_SUCCESS) {
SQLTCHAR output[256];
SQLTCHAR sqlstate[6];
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, output, ODBC_VECTOR_SIZE(output), NULL, "S");
sqlstate[5] = 0;
if (strcmp(C(sqlstate), "01S02") == 0) {
printf("Your connection seems to not support cursors, probably you are using wrong protocol version or Sybase\n");
odbc_disconnect();
ODBC_FREE();
exit(0);
}
ReportODBCError("SQLSetStmtAttr", SQL_HANDLE_STMT, odbc_stmt, retcode, __LINE__, __FILE__);
}
odbc_reset_statement();
ODBC_FREE();
}
// -------------------------------------------------
// ODBCConnect()
//
BOOL ODBCConnect(CHAR *lpServerName,CHAR *lpUserName,CHAR *lpPassword)
{
win_open(EHWP_SCREENCENTER,50,300,59,-1,3,ON,"Connessione a ...");
dispfm(10,27,1,-1,STYLE_BOLD,"#Arial",25,lpServerName);
// --------------------------------------------------------------------
// Mi connetto al server
//
EhOdbc.sqlLastError=SQLConnect(EhOdbc.hConn, // Handle della connessione
lpServerName, // Nome del server
SQL_NTS, // Nome del file / Driver da usare
lpUserName,SQL_NTS, // UserName
lpPassword,SQL_NTS); // Password
if (EhOdbc.sqlLastError!=SQL_SUCCESS&&EhOdbc.sqlLastError!=SQL_SUCCESS_WITH_INFO)
{if (!EhOdbc.fNoErrorView) ODBCError("Connect");
win_close();
return TRUE;
}
// --------------------------------------------------------------------
// Alloca memoria per comandi (ritorna puntatore in hStmt)
//
// sqlReturn=SQLAllocStmt(EhOdbc.hConn, &EhOdbc.hStmt);
//
EhOdbc.sqlLastError=SQLAllocHandle(SQL_HANDLE_STMT, EhOdbc.hConn, &EhOdbc.hStmt);
if (EhOdbc.sqlLastError!=SQL_SUCCESS) {ODBCError("SQLAllocHandle/Env"); PRG_end("Ambiente stantment:?");}
SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_READ_ONLY, 0);
SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER) SQL_SCROLLABLE , 0);
SQLSetCursorName(EhOdbc.hStmt, "SQL_CURSOR", SQL_NTS);
SQLTRY(SQL_HANDLE_STMT,"SET1",EhOdbc.hStmt,SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_ROW_BIND_TYPE, SQL_BIND_BY_COLUMN, 0));
SQLTRY(SQL_HANDLE_STMT,"SET2",EhOdbc.hStmt,SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) 1, 0));
SQLTRY(SQL_HANDLE_STMT,"SET3",EhOdbc.hStmt,SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_ROW_STATUS_PTR, NULL, 0));
SQLTRY(SQL_HANDLE_STMT,"SET4",EhOdbc.hStmt,SQLSetStmtAttr(EhOdbc.hStmt, SQL_ATTR_ROWS_FETCHED_PTR, NULL, 0));
win_close();
return FALSE;
}
int main(int argc, char **argv)
{
int rc;
HSTMT hstmt = SQL_NULL_HSTMT;
int i;
SQLINTEGER colvalue;
SQLLEN indColvalue;
test_connect();
rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt);
if (!SQL_SUCCEEDED(rc))
{
print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn);
exit(1);
}
/*
* Initialize a table with some test data.
*/
printf("Creating test table pos_update_test\n");
rc = SQLExecDirect(hstmt, (SQLCHAR *) "CREATE TEMPORARY TABLE pos_update_test(i int4, orig int4)", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
rc = SQLExecDirect(hstmt, (SQLCHAR *) "INSERT INTO pos_update_test SELECT g, g FROM generate_series(1, 10) g", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
printf("Opening a cursor for update, and fetching 10 rows\n");
rc = SQLSetStmtAttr(hstmt, SQL_ATTR_CONCURRENCY,
(SQLPOINTER) SQL_CONCUR_ROWVER, 0);
CHECK_STMT_RESULT(rc, "SQLSetStmtAttr failed", hstmt);
rc = SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE,
(SQLPOINTER) SQL_CURSOR_KEYSET_DRIVEN, 0);
CHECK_STMT_RESULT(rc, "SQLSetStmtAttr failed", hstmt);
rc = SQLBindCol(hstmt, 1, SQL_C_LONG, &colvalue, 0, &indColvalue);
CHECK_STMT_RESULT(rc, "SQLBindCol failed", hstmt);
rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT * FROM pos_update_test ORDER BY orig", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
for (i = 0; i < 5; i++)
{
rc = SQLFetch(hstmt);
if (rc == SQL_NO_DATA)
break;
if (rc == SQL_SUCCESS)
{
char buf[40];
int col;
SQLLEN ind;
for (col = 1; col <= 2; col++)
{
rc = SQLGetData(hstmt, col, SQL_C_CHAR, buf, sizeof(buf), &ind);
if (!SQL_SUCCEEDED(rc))
{
print_diag("SQLGetData failed", SQL_HANDLE_STMT, hstmt);
exit(1);
}
if (ind == SQL_NULL_DATA)
strcpy(buf, "NULL");
printf("%s%s", (col > 1) ? "\t" : "", buf);
}
printf("\n");
}
else
{
print_diag("SQLFetch failed", SQL_HANDLE_STMT, hstmt);
exit(1);
}
}
/* Do a positioned update and delete */
printf("Updating result set\n");
colvalue += 100;
rc = SQLSetPos(hstmt, 1, SQL_UPDATE, SQL_LOCK_NO_CHANGE);
CHECK_STMT_RESULT(rc, "SQLSetPos failed", hstmt);
rc = SQLFetch(hstmt);
CHECK_STMT_RESULT(rc, "SQLFetch failed", hstmt);
rc = SQLSetPos(hstmt, 1, SQL_DELETE, SQL_LOCK_NO_CHANGE);
CHECK_STMT_RESULT(rc, "SQLSetPos failed", hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/* See if the update took effect */
rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT * FROM pos_update_test ORDER BY orig", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
print_result(hstmt);
/* Clean up */
test_disconnect();
return 0;
}
SQLRETURN unixodbc_backend::do_set_statement_attribute(SQLHSTMT statement_handle, SQLINTEGER attribute, SQLPOINTER value_ptr, SQLINTEGER string_length) const
{
return SQLSetStmtAttr(statement_handle, attribute, value_ptr, string_length);
}
/*
---------------------------------------------------------
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;
}
int
main(int argc, char *argv[])
{
#define TEST_FILE "attributes.in"
const char *in_file = FREETDS_SRCDIR "/" TEST_FILE;
FILE *f;
char buf[256];
SQLINTEGER i;
SQLLEN len;
get_attr_t get_attr_p = get_attr_stmt;
odbc_connect();
/* TODO find another way */
odbc_check_cursor();
odbc_command("SET TEXTSIZE 4096");
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
f = fopen(in_file, "r");
if (!f)
f = fopen(TEST_FILE, "r");
if (!f) {
fprintf(stderr, "error opening test file\n");
exit(1);
}
line_num = 0;
while (fgets(buf, sizeof(buf), f)) {
char *p = buf, *cmd;
++line_num;
while (isspace((unsigned char) *p))
++p;
cmd = strtok(p, SEP);
/* skip comments */
if (!cmd || cmd[0] == '#' || cmd[0] == 0 || cmd[0] == '\n')
continue;
if (strcmp(cmd, "odbc") == 0) {
int odbc3 = get_int(strtok(NULL, SEP)) == 3 ? 1 : 0;
if (odbc_use_version3 != odbc3) {
odbc_use_version3 = odbc3;
odbc_disconnect();
odbc_connect();
odbc_command("SET TEXTSIZE 4096");
SQLBindCol(odbc_stmt, 1, SQL_C_SLONG, &i, sizeof(i), &len);
}
continue;
}
/* set attribute */
if (strcmp(cmd, "set") == 0) {
const struct attribute *attr = lookup_attr(strtok(NULL, SEP));
char *value = strtok(NULL, SEP);
SQLRETURN ret;
if (!value)
fatal("Line %u: value not defined\n", line_num);
ret = SQL_ERROR;
switch (attr->type) {
case type_UINTEGER:
case type_INTEGER:
ret = SQLSetStmtAttr(odbc_stmt, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLINTEGER));
break;
case type_SMALLINT:
ret = SQLSetStmtAttr(odbc_stmt, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLSMALLINT));
break;
case type_LEN:
ret = SQLSetStmtAttr(odbc_stmt, attr->value, int2ptr(lookup(value, attr->lookup)),
sizeof(SQLLEN));
break;
case type_CHARP:
ret = SQLSetStmtAttr(odbc_stmt, attr->value, (SQLPOINTER) value, SQL_NTS);
break;
case type_VOIDP:
case type_DESC:
fatal("Line %u: not implemented\n");
}
if (!SQL_SUCCEEDED(ret))
fatal("Line %u: failure not expected setting statement attribute\n", line_num);
get_attr_p = get_attr_stmt;
continue;
}
/* test attribute */
if (strcmp(cmd, "attr") == 0) {
const struct attribute *attr = lookup_attr(strtok(NULL, SEP));
char *value = strtok(NULL, SEP);
int i, expected = lookup(value, attr->lookup);
if (!value)
fatal("Line %u: value not defined\n", line_num);
i = get_attr_p(attr, expected);
if (i != expected) {
g_result = 1;
fprintf(stderr, "Line %u: invalid %s got %d(%s) expected %s\n", line_num, attr->name, i, unlookup(i, attr->lookup), value);
}
continue;
}
if (strcmp(cmd, "reset") == 0) {
odbc_reset_statement();
continue;
}
fatal("Line %u: command '%s' not handled\n", line_num, cmd);
}
fclose(f);
odbc_disconnect();
printf("Done.\n");
return g_result;
}
static int db_is_up(switch_odbc_handle_t *handle)
{
int ret = 0;
SQLHSTMT stmt = NULL;
SQLLEN m = 0;
int result;
switch_event_t *event;
switch_odbc_status_t recon = 0;
char *err_str = NULL;
SQLCHAR sql[255] = "";
int max_tries = DEFAULT_ODBC_RETRIES;
int code = 0;
SQLRETURN rc;
SQLSMALLINT nresultcols;
if (handle) {
max_tries = handle->num_retries;
if (max_tries < 1)
max_tries = DEFAULT_ODBC_RETRIES;
}
top:
if (!handle) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "No DB Handle\n");
goto done;
}
if (handle->is_oracle) {
strcpy((char *) sql, "select 1 from dual");
} else if (handle->is_firebird) {
strcpy((char *) sql, "select first 1 * from RDB$RELATIONS");
} else {
strcpy((char *) sql, "select 1");
}
if (SQLAllocHandle(SQL_HANDLE_STMT, handle->con, &stmt) != SQL_SUCCESS) {
code = __LINE__;
goto error;
}
SQLSetStmtAttr(stmt, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER)30, 0);
if (SQLPrepare(stmt, sql, SQL_NTS) != SQL_SUCCESS) {
code = __LINE__;
goto error;
}
result = SQLExecute(stmt);
if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO) {
code = __LINE__;
goto error;
}
SQLRowCount(stmt, &m);
rc = SQLNumResultCols(stmt, &nresultcols);
if (rc != SQL_SUCCESS) {
code = __LINE__;
goto error;
}
ret = (int) nresultcols;
/* determine statement type */
if (nresultcols <= 0) {
/* statement is not a select statement */
code = __LINE__;
goto error;
}
goto done;
error:
err_str = switch_odbc_handle_get_error(handle, stmt);
/* Make sure to free the handle before we try to reconnect */
if (stmt) {
SQLFreeHandle(SQL_HANDLE_STMT, stmt);
stmt = NULL;
}
recon = switch_odbc_handle_connect(handle);
max_tries--;
if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Failure-Message", "The sql server is not responding for DSN %s [%s][%d]",
switch_str_nil(handle->dsn), switch_str_nil(err_str), code);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The sql server is not responding for DSN %s [%s][%d]\n",
switch_str_nil(handle->dsn), switch_str_nil(err_str), code);
if (recon == SWITCH_ODBC_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "The connection has been re-established");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "The connection has been re-established\n");
} else {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "The connection could not be re-established");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The connection could not be re-established\n");
}
if (!max_tries) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "Giving up!");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up!\n");
}
switch_event_fire(&event);
}
if (!max_tries) {
goto done;
}
switch_safe_free(err_str);
switch_yield(1000000);
goto top;
done:
switch_safe_free(err_str);
if (stmt) {
SQLFreeHandle(SQL_HANDLE_STMT, stmt);
}
return ret;
}
int
main(int argc, char *argv[])
{
HENV env;
HDBC dbc;
HSTMT stmt;
SQLRETURN ret;
SQLINTEGER i;
Connect();
/* here we can't use temporary table cause we use two connection */
CommandWithResult(Statement, "drop table test_timeout");
Command(Statement, "create table test_timeout(n numeric(18,0) primary key, t varchar(30))");
AutoCommit(SQL_AUTOCOMMIT_OFF);
Command(Statement, "insert into test_timeout(n, t) values(1, 'initial')");
EndTransaction(SQL_COMMIT);
Command(Statement, "update test_timeout set t = 'second' where n = 1");
/* save this connection and do another */
env = Environment;
dbc = Connection;
stmt = Statement;
Environment = SQL_NULL_HENV;
Connection = SQL_NULL_HDBC;
Statement = SQL_NULL_HSTMT;
Connect();
AutoCommit(SQL_AUTOCOMMIT_OFF);
ret = SQLSetStmtAttr(Statement, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0);
if (ret != SQL_SUCCESS)
ODBC_REPORT_ERROR("Error setting timeout");
i = 1;
ret = SQLBindParameter(Statement, 1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &i, 0, NULL);
if (ret != SQL_SUCCESS)
ODBC_REPORT_ERROR("SQLBindParameter failure");
if (SQLPrepare(Statement, (SQLCHAR *) "update test_timeout set t = 'bad' where n = ?", SQL_NTS) != SQL_SUCCESS)
ODBC_REPORT_ERROR("SQLPrepare failure");
ret = SQLExecute(Statement);
if (ret != SQL_ERROR)
ODBC_REPORT_ERROR("SQLExecute success ??");
EndTransaction(SQL_ROLLBACK);
/* TODO should return error S1T00 Timeout expired, test error message */
ret = CommandWithResult(Statement, "update test_timeout set t = 'bad' where n = 1");
if (ret != SQL_ERROR)
ODBC_REPORT_ERROR("SQLExecDirect success ??");
EndTransaction(SQL_ROLLBACK);
Disconnect();
Environment = env;
Connection = dbc;
Statement = stmt;
EndTransaction(SQL_COMMIT);
/* Sybase do not accept DROP TABLE during a transaction */
AutoCommit(SQL_AUTOCOMMIT_ON);
Command(Statement, "drop table test_timeout");
Disconnect();
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;
}
/* ------------------------------------------------------------- */
PJXNODE jx_buildMetaFields ( PJXSQL pSQL )
{
LONG attrParm;
PJXNODE pFields = jx_NewArray(NULL);
int i;
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
}
for (i = 1; i <= pSQL->nresultcols; i++) {
PJXNODE pField = jx_NewObject (NULL);
PJXCOL pCol = &pSQL->cols[i-1];
PUCHAR type = "string";
UCHAR temp [256];
// Add name
jx_NodeAdd (pField , RL_LAST_CHILD, "name" , pCol->colname, VALUE );
// Add type
switch( pCol->coltype) {
case SQL_BLOB: type = "blob" ; break;
case SQL_CLOB: type = "clob" ; break;
case SQL_CHAR: type = "char" ; break;
case SQL_VARCHAR: type = "varchar" ; break;
case SQL_DATETIME: type = "datetime" ; break;
case SQL_DATE: type = "date" ; break;
case SQL_TIME: type = "time" ; break;
case SQL_TIMESTAMP: type = "timestamp" ; break;
case SQL_WCHAR: type = "wchar" ; break;
case SQL_WVARCHAR: type = "wvarchar" ; break;
case SQL_GRAPHIC: type = "graphic" ; break;
case SQL_VARGRAPHIC: type = "vargraphic" ; break;
default: {
if (pCol->coltype >= SQL_NUMERIC && pCol->coltype <= SQL_DOUBLE ) {
if (pCol->scale > 0) {
type = "dec" ;
} else {
type = "int" ;
}
} else {
sprintf(temp ,"unknown%d" , pCol->coltype);
type = temp;
}
}
}
jx_NodeAdd (pField , RL_LAST_CHILD, "datatype" , type, VALUE );
// Add size
sprintf(temp , "%d" , pCol->displaysize);
jx_NodeAdd (pField , RL_LAST_CHILD, "size" , temp, LITERAL );
// Add decimal precission
if (pCol->coltype >= SQL_NUMERIC && pCol->coltype <= SQL_DOUBLE
&& pCol->scale > 0) {
sprintf(temp , "%d" , pCol->scale);
jx_NodeAdd (pField , RL_LAST_CHILD, "prec" , temp, LITERAL );
}
// Push to array
jx_ArrayPush (pFields , pField, FALSE);
}
// jx_Debug ("Fields:", pFields);
return pFields;
}
static void
query_test(const char* expected, const char *expected_status)
{
#define ARRAY_SIZE 10
ODBC_BUF *odbc_buf = NULL;
SQLUINTEGER *ids;
SQLCHAR *descs;
SQLLEN *id_lens, *desc_lens;
SQLULEN processed;
SQLUSMALLINT i, statuses[ARRAY_SIZE];
int desc_len = trunc ? 4 : 51;
int rec_size = 0;
Record *rec = NULL;
char status[20];
assert(odbc_stmt != SQL_NULL_HSTMT);
odbc_reset_statement();
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_ROW_STATUS_PTR, statuses, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (void *) ARRAY_SIZE, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_ROWS_FETCHED_PTR, &processed, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_ROW_BIND_TYPE, SQL_BIND_BY_COLUMN, 0);
if (!record_bind) {
ids = (SQLUINTEGER *) ODBC_GET(sizeof(SQLUINTEGER) * ARRAY_SIZE);
descs = ODBC_GET(sizeof(SQLCHAR) * ARRAY_SIZE * desc_len);
desc_lens = (SQLLEN *) ODBC_GET(sizeof(SQLLEN) * ARRAY_SIZE);
id_lens = (SQLLEN *) ODBC_GET(sizeof(SQLLEN) * ARRAY_SIZE);
assert(descs && ids && desc_lens && id_lens);
} else {
rec_size = (sizeof(Record) + (sizeof(SQLCHAR) * desc_len + sizeof(SQLLEN) - 1)) & ~(sizeof(SQLLEN) - 1);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_ROW_BIND_TYPE, int2ptr(rec_size), 0);
rec = (Record *) ODBC_GET(rec_size * ARRAY_SIZE);
ids = &rec->id;
id_lens = &rec->id_len;
desc_lens = &rec->desc_len;
descs = (SQLCHAR *) (((char *) rec) + sizeof(Record));
}
#define REC(f,n) (((char*)f)+rec_size*(n))
#define DESCS(n) (rec ? (SQLCHAR*)REC(descs,n): (descs+(n)*desc_len))
#define IDS(n) *(rec ? (SQLUINTEGER*)REC(ids,n) : &ids[n])
#define ID_LENS(n) *(rec ? (SQLLEN*)REC(id_lens,n) : &id_lens[n])
#define DESC_LENS(n) *(rec ? (SQLLEN*)REC(desc_lens,n) : &desc_lens[n])
processed = ARRAY_SIZE + 1;
for (i = 0; i < ARRAY_SIZE; i++) {
statuses[i] = SQL_ROW_UPDATED;
IDS(i) = i * 132;
sprintf((char *) DESCS(i), "aaa");
ID_LENS(i) = 0;
DESC_LENS(i) = -i;
}
SQLBindCol(odbc_stmt, 1, SQL_C_ULONG, &IDS(0), 0, &ID_LENS(0));
SQLBindCol(odbc_stmt, 2, SQL_C_CHAR, DESCS(0), desc_len, &DESC_LENS(0));
CHKExecDirect(T(test_query), SQL_NTS, "S");
CHKFetch(expected);
assert(processed <= ARRAY_SIZE);
for (i = 0; i < processed; ++i) {
char buf[128];
sprintf(buf, "%crow number %d", 'a' + i, i * 13);
if (trunc)
buf[3] = 0;
if (IDS(i) != i + 1 || strcmp((char *) DESCS(i), buf) != 0) {
fprintf(stderr, "Invalid result\n\tgot '%d|%s'\n\texpected '%d|%s'\n", (int) IDS(i), DESCS(i), i + 1, buf);
exit(1);
}
switch (statuses[i]) {
case SQL_ROW_SUCCESS:
status[i] = 'V';
break;
case SQL_ROW_SUCCESS_WITH_INFO:
status[i] = 'v';
break;
case SQL_ROW_ERROR:
status[i] = '!';
break;
case SQL_ROW_NOROW:
status[i] = ' ';
break;
default:
fprintf(stderr, "Invalid status returned\n");
exit(1);
}
}
status[i] = 0;
if (expected_status && strcmp(expected_status, status) != 0) {
fprintf(stderr, "Invalid status\n\tgot '%s'\n\texpected '%s'\n", status, expected_status);
exit(1);
}
ODBC_FREE();
}
static int odbc_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options)
{
RETCODE rc;
pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
pdo_odbc_stmt *S = ecalloc(1, sizeof(*S));
enum pdo_cursor_type cursor_type = PDO_CURSOR_FWDONLY;
int ret;
char *nsql = NULL;
size_t nsql_len = 0;
S->H = H;
S->assume_utf8 = H->assume_utf8;
/* before we prepare, we need to peek at the query; if it uses named parameters,
* we want PDO to rewrite them for us */
stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL;
ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len);
if (ret == 1) {
/* query was re-written */
sql = nsql;
} else if (ret == -1) {
/* couldn't grok it */
strcpy(dbh->error_code, stmt->error_code);
efree(S);
return 0;
}
rc = SQLAllocHandle(SQL_HANDLE_STMT, H->dbc, &S->stmt);
if (rc == SQL_INVALID_HANDLE || rc == SQL_ERROR) {
efree(S);
if (nsql) {
efree(nsql);
}
pdo_odbc_drv_error("SQLAllocStmt");
return 0;
}
cursor_type = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY);
if (cursor_type != PDO_CURSOR_FWDONLY) {
rc = SQLSetStmtAttr(S->stmt, SQL_ATTR_CURSOR_SCROLLABLE, (void*)SQL_SCROLLABLE, 0);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
pdo_odbc_stmt_error("SQLSetStmtAttr: SQL_ATTR_CURSOR_SCROLLABLE");
SQLFreeHandle(SQL_HANDLE_STMT, S->stmt);
if (nsql) {
efree(nsql);
}
return 0;
}
}
rc = SQLPrepare(S->stmt, (char*)sql, SQL_NTS);
if (nsql) {
efree(nsql);
}
stmt->driver_data = S;
stmt->methods = &odbc_stmt_methods;
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLPrepare");
if (rc != SQL_SUCCESS_WITH_INFO) {
/* clone error information into the db handle */
strcpy(H->einfo.last_err_msg, S->einfo.last_err_msg);
H->einfo.file = S->einfo.file;
H->einfo.line = S->einfo.line;
H->einfo.what = S->einfo.what;
strcpy(dbh->error_code, stmt->error_code);
}
}
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
return 1;
}
int main(int argc, char **argv)
{
SQLRETURN rc;
HSTMT hstmt = SQL_NULL_HSTMT;
char *param1, *param2;
SQLLEN cbParam1, cbParam2;
SQLLEN param1bytes, param2bytes;
PTR paramid;
SQLLEN str_ind_array[2];
SQLUSMALLINT status_array[2];
SQLULEN nprocessed = 0;
int i;
test_connect();
rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt);
if (!SQL_SUCCEEDED(rc))
{
print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn);
exit(1);
}
/****
* Bind with data-at-execution params. (VARBINARY)
*/
/* Prepare a statement */
rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id FROM byteatab WHERE t = ? OR t = ?", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt);
/* prepare the parameter values */
param1 = "bar";
param1bytes = strlen(param1);
cbParam1 = SQL_DATA_AT_EXEC;
param2 = "foobar";
param2bytes = strlen(param2);
cbParam2 = SQL_DATA_AT_EXEC;
/* bind them. */
rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_BINARY, /* value type */
SQL_VARBINARY, /* param type */
param1bytes, /* column size */
0, /* dec digits */
(void *) 1, /* param value ptr. For a data-at-exec
* param, this is a "parameter id" */
0, /* buffer len */
&cbParam1 /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
rc = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT,
SQL_C_BINARY, /* value type */
SQL_VARBINARY, /* param type */
param2bytes, /* column size */
0, /* dec digits */
(void *) 2, /* param value ptr. For a data-at-exec
* param, this is a "parameter id" */
0, /* buffer len */
&cbParam2 /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
/* Execute */
rc = SQLExecute(hstmt);
if (rc != SQL_NEED_DATA)
CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt);
/* set parameters */
paramid = 0;
while ((rc = SQLParamData(hstmt, ¶mid)) == SQL_NEED_DATA)
{
if (paramid == (void *) 1)
{
rc = SQLPutData(hstmt, param1, param1bytes);
CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt);
}
else if (paramid == (void *) 2)
{
rc = SQLPutData(hstmt, param2, param2bytes);
CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt);
}
else
{
printf("unexpected parameter id returned by SQLParamData: %p\n", paramid);
exit(1);
}
}
CHECK_STMT_RESULT(rc, "SQLParamData failed", hstmt);
/* Fetch result */
print_result(hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/****
* Array binding with data-at-execution params.
*/
/* prepare the parameter values */
str_ind_array[0] = SQL_DATA_AT_EXEC;
str_ind_array[1] = SQL_DATA_AT_EXEC;
/* Prepare a statement */
rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id FROM byteatab WHERE t = ?", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt);
SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_STATUS_PTR, status_array, 0);
SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &nprocessed, 0);
SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) 2, 0);
/* bind the array. */
rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_BINARY, /* value type */
SQL_VARBINARY, /* param type */
5, /* column size */
0, /* dec digits */
(void *) 1, /* param value ptr. For a data-at-exec
* param, this is "parameter id" */
0, /* buffer len */
str_ind_array /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
/* Execute */
rc = SQLExecute(hstmt);
if (rc != SQL_NEED_DATA)
CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt);
/* set parameters */
paramid = 0;
while ((rc = SQLParamData(hstmt, ¶mid)) == SQL_NEED_DATA)
{
if (nprocessed == 1)
rc = SQLPutData(hstmt, "foo", strlen("foo"));
else if (nprocessed == 2)
rc = SQLPutData(hstmt, "barf", strlen("barf"));
else
{
printf("unexpected # of rows processed after SQL_NEED_DATA: %u\n", (unsigned int) nprocessed);
exit(1);
}
CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt);
}
CHECK_STMT_RESULT(rc, "SQLParamData failed", hstmt);
/* Fetch results */
printf("Parameter Status\n");
for (i = 0; i < nprocessed; i++)
{
switch (status_array[i])
{
case SQL_PARAM_SUCCESS:
case SQL_PARAM_SUCCESS_WITH_INFO:
break;
case SQL_PARAM_ERROR:
printf("%d\tError\n", i);
break;
case SQL_PARAM_UNUSED:
printf("%d\tUnused\n", i);
break;
case SQL_PARAM_DIAG_UNAVAILABLE:
printf("%d\tDiag unavailable\n", i);
break;
}
}
printf ("Fetching result sets for array bound (%u results expected)\n",
(unsigned int) nprocessed);
for (i = 1; rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO; i++)
{
printf("%d: ", i);
print_result(hstmt);
rc = SQLMoreResults(hstmt);
}
if (rc != SQL_NO_DATA)
CHECK_STMT_RESULT(rc, "SQLMoreResults failed", hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/* Clean up */
test_disconnect();
return 0;
}
/*----------------------------------------------------------------------------------------------
Save data in the cache, to the database.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP VwRsOdbcDa::Save(SqlDb & sdb)
{
BEGIN_COM_METHOD
const kcchErrMsgBuf = 1024;
const kcbFmtBufMax = 1024;
const kcchMaxColNameSize = 200;
SQLINTEGER cbColVal;
SDWORD cbClassName;
long cbHvo;
SDWORD cbFieldName;
SDWORD cbFlid;
int cbFmtBufSize = kcbFmtBufMax;
int cbFmtSpaceTaken;
SDWORD cbType;
SQLUSMALLINT cParamsProcessed = 0;
HRESULT hr;
FieldMetaDataMap fmdm; // REVIEW PaulP: Would be nice to have this kept globally.
FieldMetaDataRec fmdr;
int nColVal;
int nFlid;
ITsStringPtr qtssColVal;
RETCODE rc;
byte * rgbFmt = NewObj byte[kcbFmtBufMax]; //[kcbFmtBufMax];
SmartBstr sbstr;
SQLCHAR sqlchSqlState[5];
SQLCHAR sqlchMsgTxt[kcchErrMsgBuf];
SQLINTEGER sqlnNativeErrPtr;
SQLSMALLINT sqlnTextLength;
SQLRETURN sqlr;
SqlStatement sstmt;
StrUni suColumnName;
StrUni suFieldMetaDataSql;
StrUni suSql;
StrUni suTableName;
wchar wchClassName[kcchMaxColNameSize];
wchar wchFieldName[kcchMaxColNameSize];
Assert(sdb.IsOpen());
/*------------------------------------------------------------------------------------------
If a pointer to a HashMap of field$ metadata information was not passed in as a
parameter, create the HashMap. The metaData includes all field names, field types,
class names, and destination class name from the field$ and class$ tables.
This information is needed since only store the "flid" value is stored in the cache
(as the "tag") so when it comes time to do SQL "insert" and "update" statements,
one need's to know what table and column needs to be affected.
REVIEW PaulP: Should really cache this information globally so that it does not have
to be reloaded each time the view cache is saved. The only time this info would have
to be reloaded is when custom fields are added. Perhaps we could have a table with
a single record which indicates the last date/time a change to the database was made.
This could be compared with the currently loaded date each time the cache is saved to
see if there is a need to reload the field$ meta information. Of course, if we
require that only one user is allowed to be connected for a custom field addition,
this would not be necessary.
TOxDO PaulP: Cleanup on any error exit, including db rollback.
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_ROLLBACK));
------------------------------------------------------------------------------------------*/
try
{
// Set up SQL statment to obtain meta data.
suFieldMetaDataSql.Format(
L"select f.Id FLID, Type, f.Name FLD_NAME,"
L" c.Name CLS_NAME"
L" from Field$ f"
L" join Class$ c on c.id = f.Class"
L" order by f.id");
sstmt.Init(sdb);
CheckSqlRc(SQLExecDirectW(sstmt.Hstmt(), \
const_cast<wchar *>(suFieldMetaDataSql.Chars()), SQL_NTS));
// Bind Columns.
rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAMS_PROCESSED_PTR, &cParamsProcessed, 0);
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 1, SQL_C_SLONG, &nFlid, isizeof(int),
&cbFlid));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 2, SQL_C_SLONG, &fmdr.m_iType,
isizeof(fmdr.m_iType), &cbType));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 3, SQL_C_WCHAR, &wchFieldName,
kcchMaxColNameSize, &cbFieldName));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 4, SQL_C_WCHAR, &wchClassName,
kcchMaxColNameSize, &cbClassName));
// Put info from the columns into a FieldMetaDataRec record and insert
// this in the FieldMetaData HashMap.
for (;;)
{
rc = SQLFetch(sstmt.Hstmt());
if (rc != SQL_SUCCESS)
break;
// TOxDO PaulP: Change this so it just gets a null terminated string!!!
fmdr.m_suFieldName.Assign(wchFieldName, kcchMaxColNameSize);
fmdr.m_suClassName.Assign(wchClassName, kcchMaxColNameSize);
fmdm.Insert(nFlid, fmdr);
}
if (rc != SQL_NO_DATA)
{
// REVIEW PaulP (SteveMc): Handle possible error message?
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
catch (...)
{
sstmt.Clear();
delete rgbFmt;
return E_UNEXPECTED;
}
/*------------------------------------------------------------------------------------------
For every key in the "m_soprMods" ObjPropSet set (ie. all the object properties
that have been updated), look up that key in the appropriate HashMap and form an SQL
"update" statement according to the field$ "Type".
This begins a single database transaction. All the data in the application view cache
must either be inserted/updated to the database successfully or the action should fail.
This necessitates that the database connection is in manual-commit mode.
REVIEW PaulP: It is probably faster to collect all the properties for a given object
type and update the table in the database all with one SQL statement but this will
do for now until the OLE DB stuff is done.
------------------------------------------------------------------------------------------*/
try
{
ObjPropSet::iterator itops;
for (itops = m_soprMods.Begin(); itops != m_soprMods.End(); ++itops)
{
// Get the oprKey from the "update object property" Set.
ObjPropRec & oprKey = itops.GetValue();
// Get the field$ metadata information based on the tag of that oprKey.
fmdm.Retrieve(oprKey.m_tag, &fmdr);
// Initialize and form the SQL statment based on the field "type".
sstmt.Init(sdb);
switch (fmdr.m_iType)
{
case kcptNil:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptBoolean:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptInteger:
// Prepare the SQL statement. (Uses parameters).
suSql.Format(L"update %s set %s=? where id=?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
// Get the integer value from the appropriate HashMap.
if (m_hmoprn.Retrieve(oprKey, &nColVal))
{
// Bind integer value as the first parameter.
if (nColVal)
{
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, &nColVal, 0, &cbColVal);
}
else
{
// REVIEW JohnT: How do we indicate in the HashMap that the user
// wants to set an integer to NULL?
cbColVal = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, NULL, 0, &cbColVal);
}
// Bind the HVO (Id) as the second parameter.
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
break;
case kcptNumeric:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptFloat:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptTime:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptGuid:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptImage:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptGenDate:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptBinary:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptString:
case kcptBigString:
// Prepare the SQL statement. (Uses parameters.)
// REVIEW PaulP: Should I be hard-coding "_Fmt" in like this?
suSql.Format(L"update %s set %s=?, %s_Fmt=? where id=?",
fmdr.m_suClassName.Chars(), fmdr.m_suFieldName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
if (m_hmoprtss.Retrieve(oprKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that points
// to the TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Copy format information of the TsString to byte array rgbFmt.
hr = qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken);
if (hr != S_OK)
{
if (hr == S_FALSE)
{
// If the supplied buffer is too small, try it again with
// the value that cbFmtSpaceTaken was set to. If this
// fails, throw error.
delete rgbFmt;
rgbFmt = NewObj byte[cbFmtSpaceTaken];
cbFmtBufSize = cbFmtSpaceTaken;
CheckHr(qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken));
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
// Bind the text and format parts of the string to the parameters.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
SQLINTEGER cbFmtPart = cbFmtSpaceTaken;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_BINARY, SQL_VARBINARY, cbFmtPart, 0, rgbFmt, cbFmtPart,
&cbFmtPart);
}
else
{
// Since the string had no length, bind NULL to the parameters.
SQLINTEGER cbTextPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, 1, 0, NULL, 0, &cbTextPart);
// REVIEW PaulP: Should we set the Fmt info to NULL for NULL
// strings or should we use the Fmt info returned from the
// TsString?
SQLINTEGER cbFmtPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_BINARY, SQL_VARBINARY, 1, 0, NULL, 0, &cbFmtPart);
}
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
// Bind the HVO (ie. Id) value.
rc = SQLBindParameter(sstmt.Hstmt(), 3, SQL_PARAM_INPUT, SQL_C_SLONG,
SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
break;
case kcptBigUnicode:
case kcptUnicode:
// Prepare the SQL statement. (Uses parameters.)
suSql.Format(L"update %s set %s=? where id=?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
if (m_hmoprtss.Retrieve(oprKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that
// points to a TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Bind the string parameter.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
}
else
{
// If the string had no length, bind NULL to the parameter.
SQLINTEGER cbTextPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, 1, 0, NULL, 0, &cbTextPart);
}
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
// Bind the HVO (ie. Id) value.
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT, SQL_C_SLONG,
SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
break;
case kcptOwningAtom:
// Update owning field.
// Update Owner$ object of CmObject.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceAtom:
// This is basically the same as the Integer case except we obtain the
// value from the m_hmoprobj HashMap rather than the m_hmoprn HashMap.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptOwningCollection:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceCollection:
// Affect the joiner table.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptOwningSequence:
// Need to update.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceSequence:
// Affect the joiner table.
ThrowHr(WarnHr(E_NOTIMPL));
break;
default:
ThrowHr(WarnHr(E_UNEXPECTED));
break;
}
// Execute the SQL update command.
//rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
rc = SQLExecute(sstmt.Hstmt());
if (rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO)
{
// TOxDO PaulP: Error information can be obtained from sqlchMsgTxt.
sqlr = SQLGetDiagRec(SQL_HANDLE_STMT, sstmt.Hstmt(), 1, sqlchSqlState,
&sqlnNativeErrPtr, sqlchMsgTxt, kcchErrMsgBuf, &sqlnTextLength);
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
/*--------------------------------------------------------------------------------------
Go through the m_soperMods ObjPropSet set and update columns in the MultiX tables.
--------------------------------------------------------------------------------------*/
ObjPropEncSet::iterator itopes;
for (itopes = m_soperMods.Begin(); itopes != m_soperMods.End(); ++itopes)
{
// Get the operKey from the "update MSA" Set.
ObjPropEncRec & operKey = itopes.GetValue();
// Get the field$ metadata information based on the tag of that operKey.
fmdm.Retrieve(operKey.m_tag, &fmdr);
// Initialize and form the SQL statment.
sstmt.Init(sdb);
if (m_hmopertss.Retrieve(operKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that points to the TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Get the format of the TsString
hr = qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize, &cbFmtSpaceTaken);
if (hr != S_OK)
{
if (hr == S_FALSE)
{
// If the supplied buffer is too small, try it again with the value
// that cbFmtSpaceTaken was set to. If this fails, signal error.
delete rgbFmt;
rgbFmt = NewObj byte[cbFmtSpaceTaken];
cbFmtBufSize = cbFmtSpaceTaken;
CheckHr(qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken));
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
// Execute stored procedure to set MSA value.
// REVIEW PaulP: This technique isn't going to work for custom fields
// since there will likely not be any "Set" stored procedure.
suSql.Format(L"exec Set_%s_%s %d, %d, ?, ?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars(), operKey.m_hvo, operKey.m_ws);
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
// Bind the text and format parts of the string to the parameters.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
SQLINTEGER cbFmtPart = cbFmtSpaceTaken;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT, SQL_C_BINARY,
SQL_VARBINARY, cbFmtPart, 0, rgbFmt, cbFmtPart, &cbFmtPart);
}
else
{
// REVIEW PaulP: This technique isn't going to work for custom fields
// since there will likely not be any "Set" stored procedure.
suSql.Format(L"exec Set_%s_%s %d, %d, NULL, NULL",
fmdr.m_suClassName.Chars(), fmdr.m_suFieldName.Chars(), operKey.m_hvo,
operKey.m_ws);
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
}
// Execute the SQL update command.
//rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
rc = SQLExecute(sstmt.Hstmt());
if (rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO)
{
// TOxDO PaulP: Error information can be obtained from sqlchMsgTxt.
sqlr = SQLGetDiagRec(SQL_HANDLE_STMT, sstmt.Hstmt(), 1, sqlchSqlState,
&sqlnNativeErrPtr, sqlchMsgTxt, kcchErrMsgBuf, &sqlnTextLength);
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
/*--------------------------------------------------------------------------------------
Commit the database transaction.
REVIEW PaulP: The DataSource MUST be in manual commit mode.
--------------------------------------------------------------------------------------*/
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_COMMIT));
}
catch (...)
{
sstmt.Clear();
delete rgbFmt;
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_ROLLBACK));
return E_UNEXPECTED;
}
/*------------------------------------------------------------------------------------------
Clear the two Sets containing records of modified properties and MBA's.
------------------------------------------------------------------------------------------*/
m_soprMods.Clear();
m_soperMods.Clear();
delete rgbFmt; // REVIEW: Shouldn't this be delete[]?
return S_OK;
END_COM_METHOD(g_fact, IID_IVwCacheDa);
}
/* ------------------------------------------------------------- */
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;
}
