int
backsql_count_children(
Operation *op,
SQLHDBC dbh,
struct berval *dn,
unsigned long *nchildren )
{
backsql_info *bi = (backsql_info *)op->o_bd->be_private;
SQLHSTMT sth = SQL_NULL_HSTMT;
BACKSQL_ROW_NTS row;
RETCODE rc;
int res = LDAP_SUCCESS;
Debug( LDAP_DEBUG_TRACE, "==>backsql_count_children(): dn=\"%s\"\n",
dn->bv_val, 0, 0 );
if ( dn->bv_len > BACKSQL_MAX_DN_LEN ) {
Debug( LDAP_DEBUG_TRACE,
"backsql_count_children(): DN \"%s\" (%ld bytes) "
"exceeds max DN length (%d):\n",
dn->bv_val, dn->bv_len, BACKSQL_MAX_DN_LEN );
return LDAP_OTHER;
}
/* begin TimesTen */
Debug(LDAP_DEBUG_TRACE, "children id query \"%s\"\n",
bi->sql_has_children_query, 0, 0);
assert( bi->sql_has_children_query != NULL );
rc = backsql_Prepare( dbh, &sth, bi->sql_has_children_query, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"backsql_count_children(): error preparing SQL:\n%s",
bi->sql_has_children_query, 0, 0);
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
return LDAP_OTHER;
}
rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, dn );
if ( rc != SQL_SUCCESS) {
/* end TimesTen */
Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): "
"error binding dn=\"%s\" parameter:\n",
dn->bv_val, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
return LDAP_OTHER;
}
rc = SQLExecute( sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): "
"error executing query (\"%s\", \"%s\"):\n",
bi->sql_has_children_query, dn->bv_val, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
return LDAP_OTHER;
}
backsql_BindRowAsStrings_x( sth, &row, op->o_tmpmemctx );
rc = SQLFetch( sth );
if ( BACKSQL_SUCCESS( rc ) ) {
char *end;
*nchildren = strtol( row.cols[ 0 ], &end, 0 );
if ( end == row.cols[ 0 ] ) {
res = LDAP_OTHER;
} else {
switch ( end[ 0 ] ) {
case '\0':
break;
case '.': {
unsigned long ul;
/* FIXME: braindead RDBMSes return
* a fractional number from COUNT!
*/
if ( lutil_atoul( &ul, end + 1 ) != 0 || ul != 0 ) {
res = LDAP_OTHER;
}
} break;
default:
res = LDAP_OTHER;
}
}
} else {
res = LDAP_OTHER;
}
backsql_FreeRow_x( &row, op->o_tmpmemctx );
SQLFreeStmt( sth, SQL_DROP );
Debug( LDAP_DEBUG_TRACE, "<==backsql_count_children(): %lu\n",
*nchildren, 0, 0 );
return res;
}
void CMailMgr::RecvRequestBody(const int cn,t_packet *p)
{//바디를 찾습니다.
t_packet packet;
packet.h.header.type = CMD_MAIL_REQ_BODY_RESULT;
packet.h.header.size = sizeof(REQESTMAILBODYRESULT);
ZeroMemory(&packet.u.Hwoa.rang.ReqestMailBodyResult,sizeof(REQESTMAILBODYRESULT));
LPREQESTMAILBODYRESULT pRMBR= &packet.u.Hwoa.rang.ReqestMailBodyResult;
const int iMainIndex = p->u.Hwoa.rang.ReqestMailBody.iMailIndex;
if(!iMainIndex){return;}
char szQuerry[MAX_PATH] = {0,};
HSTMT hStmt = NULL;
RETCODE retCode;
SDWORD cbValue;
::sprintf(szQuerry, "EXEC MailGetData %d, '%s'",
iMainIndex, p->u.Hwoa.rang.ReqestMailBody.szName);
::SQLAllocStmt(hDBC, &hStmt);
retCode = ::SQLExecDirect(hStmt, (UCHAR *)szQuerry, SQL_NTS);
if(retCode == SQL_SUCCESS || retCode == SQL_SUCCESS_WITH_INFO)
{
retCode = ::SQLFetch(hStmt);
int column = 0;
retCode = ::SQLGetData(hStmt, ++column, SQL_C_LONG, &pRMBR->iMailIndex, 0, &cbValue);
retCode = ::SQLGetData(hStmt, ++column, SQL_C_LONG, &pRMBR->iType, 0, &cbValue);
retCode = ::SQLGetData(hStmt, ++column, SQL_C_CHAR, pRMBR->szSender, MAX_NAME, &cbValue);
::EatRearWhiteChar(pRMBR->szSender);
retCode = ::SQLGetData(hStmt, ++column, SQL_C_CHAR, pRMBR->szReceiver, MAX_NAME, &cbValue);
::EatRearWhiteChar(pRMBR->szReceiver);
retCode = ::SQLGetData(hStmt, ++column, SQL_C_CHAR, pRMBR->szTitle, 60, &cbValue);
::EatRearWhiteChar(pRMBR->szTitle);
retCode = ::SQLGetData(hStmt, ++column, SQL_C_TIMESTAMP, &pRMBR->date, sizeof( TIMESTAMP_STRUCT ), &cbValue);
::SQLFreeStmt(hStmt, SQL_DROP);
}
else
{
::SQLFreeStmt(hStmt, SQL_DROP);
return;
}
::sprintf(szQuerry, "EXEC MailGetBody %d, '%s'",
iMainIndex, p->u.Hwoa.rang.ReqestMailBody.szName);
::SQLAllocStmt(hDBC, &hStmt);
retCode = SQLExecDirect(hStmt, (UCHAR *)szQuerry, SQL_NTS);
if(retCode == SQL_SUCCESS || retCode == SQL_SUCCESS_WITH_INFO)
{
retCode = SQLFetch(hStmt);
int column = 0;
retCode = SQLGetData(hStmt, ++column, SQL_C_CHAR, pRMBR->szBody, MAX_MAIL_BODY_LEN, &cbValue);
::EatRearWhiteChar(pRMBR->szBody);
SQLFreeStmt(hStmt, SQL_DROP);
const int iBodyLength = strlen(pRMBR->szBody);
packet.h.header.size = sizeof(REQESTMAILBODYRESULT)+iBodyLength+1-MAX_MAIL_BODY_LEN;
}
else
{
SQLFreeStmt(hStmt, SQL_DROP);
return;
}
::QueuePacket(connections,cn,&packet,1);//맵서버로 돌려보낸다
}
static int
backsql_delete_int(
Operation *op,
SlapReply *rs,
SQLHDBC dbh,
SQLHSTMT *sthp,
backsql_entryID *eid,
Entry **ep )
{
backsql_info *bi = (backsql_info*)op->o_bd->be_private;
SQLHSTMT sth = SQL_NULL_HSTMT;
RETCODE rc;
int prc = LDAP_SUCCESS;
/* first parameter no */
SQLUSMALLINT pno = 0;
sth = *sthp;
/* avl_apply ... */
rs->sr_err = backsql_delete_all_attrs( op, rs, dbh, eid );
if ( rs->sr_err != LDAP_SUCCESS ) {
goto done;
}
rc = backsql_Prepare( dbh, &sth, eid->eid_oc->bom_delete_proc, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error preparing delete query\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
*ep = NULL;
goto done;
}
if ( BACKSQL_IS_DEL( eid->eid_oc->bom_expect_return ) ) {
pno = 1;
rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &prc );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error binding output parameter for objectClass %s\n",
eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
*ep = NULL;
goto done;
}
}
rc = backsql_BindParamID( sth, pno + 1, SQL_PARAM_INPUT, &eid->eid_keyval );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error binding keyval parameter for objectClass %s\n",
eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
*ep = NULL;
goto done;
}
rc = SQLExecute( sth );
if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS ) {
rs->sr_err = LDAP_SUCCESS;
} else {
Debug( LDAP_DEBUG_TRACE, " backsql_delete(): "
"delete_proc execution failed (rc=%d, prc=%d)\n",
rc, prc, 0 );
if ( prc != LDAP_SUCCESS ) {
/* SQL procedure executed fine
* but returned an error */
rs->sr_err = BACKSQL_SANITIZE_ERROR( prc );
} else {
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
rs->sr_err = LDAP_OTHER;
}
SQLFreeStmt( sth, SQL_DROP );
goto done;
}
SQLFreeStmt( sth, SQL_DROP );
/* delete "auxiliary" objectClasses, if any... */
rc = backsql_Prepare( dbh, &sth, bi->sql_delobjclasses_stmt, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error preparing ldap_entry_objclasses delete query\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
*ep = NULL;
goto done;
}
rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &eid->eid_id );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error binding auxiliary objectClasses "
"entry ID parameter for objectClass %s\n",
eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
*ep = NULL;
goto done;
}
rc = SQLExecute( sth );
switch ( rc ) {
case SQL_NO_DATA:
/* apparently there were no "auxiliary" objectClasses
* for this entry... */
case SQL_SUCCESS:
break;
default:
Debug( LDAP_DEBUG_TRACE, " backsql_delete(): "
"failed to delete record from ldap_entry_objclasses\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
*ep = NULL;
goto done;
}
SQLFreeStmt( sth, SQL_DROP );
/* delete entry... */
rc = backsql_Prepare( dbh, &sth, bi->sql_delentry_stmt, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error preparing ldap_entries delete query\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
*ep = NULL;
goto done;
}
rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &eid->eid_id );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_delete(): "
"error binding entry ID parameter "
"for objectClass %s\n",
eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
*ep = NULL;
goto done;
}
rc = SQLExecute( sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, " backsql_delete(): "
"failed to delete record from ldap_entries\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
*ep = NULL;
goto done;
}
SQLFreeStmt( sth, SQL_DROP );
rs->sr_err = LDAP_SUCCESS;
*ep = NULL;
done:;
*sthp = sth;
return rs->sr_err;
}
NPError
StatementObject::Execute(NPString *query)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
NPError rc = Close();
if (rc != NPERR_NO_ERROR)
return rc;
/**********/
int i = 0;
VecODBCParams::iterator p;
if (!m_params.empty()) {
for(p = m_params.begin(); p < m_params.end(); p++) {
nsODBCParam *val = *p;
if (val == NULL) {
return NPERR_GENERIC_ERROR;
}
i++;
switch(val->mType) {
case nsODBCParam::VTYPE_BOOL :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_BIT, SQL_BIT, sizeof(bool), 0, &(val->mVal.mBoolValue),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_INT32 :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, sizeof(int), 0, &(val->mVal.mInt32Value),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_DOUBLE :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_DOUBLE, SQL_DOUBLE, sizeof(double), 0, &(val->mVal.mDoubleValue),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_STRING :
{
nsWString *v_str = val->mVal.mStringValue;
val->mInd = SQL_NTS;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_WCHAR, (val->mIsLong?SQL_WLONGVARCHAR:SQL_WVARCHAR),
v_str->Length(), 0, v_str->Data(), 0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
#if 0
case nsIDataType::VTYPE_ARRAY :
{
nsBinary *v_bin = val->mVal.mBinValue;
val->mInd = v_bin->Length();
rv = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_BINARY, (val->mIsLong?SQL_LONGVARBINARY:SQL_VARBINARY),
v_bin->Length(), 0, v_bin->Data(), 0, (SQLINTEGER *)&(val->mInd)));
if (rv != NS_OK)
return rv;
break;
}
#endif
default:
{
val->mInd = SQL_NULL_DATA;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_CHAR, SQL_VARCHAR, 0, 0, NULL, 0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
}
}
}
/**********/
SQLRETURN code = SQLExecDirectW (m_hstmt, nsWString(query).Data(), SQL_NTS);
if (!SQL_SUCCEEDED(code) && code != SQL_NO_DATA) {
StoreError(SQL_HANDLE_STMT, m_hstmt);
ClearParams();
return NPERR_GENERIC_ERROR;
}
SQLFreeStmt (m_hstmt, SQL_RESET_PARAMS);
ClearParams();
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
SQLLEN rcnt;
if (SQL_SUCCEEDED(SQLRowCount(m_hstmt, &rcnt)))
m_rowCount = rcnt;
return NPERR_NO_ERROR;
}
/**
* Handles the message sent for the creation of housing hooks in the world.
*
* This function is called whenever a housing hook should be created for a client.
*
* @return cMessage - Returns a Create Object (0x0000F745) server message.
*/
cMessage cHooks::CreatePacket()
{
cMessage cmCreate;
char szCommand[200];
RETCODE retcode;
char OwnerIDBuff[9];
DWORD OwnerID = 0x0L;
sprintf( szCommand, "SELECT OwnerID FROM houses_covenants WHERE HouseID = %d;",m_dwHouseID);
retcode = SQLPrepare( cDatabase::m_hStmt, (unsigned char *)szCommand, SQL_NTS ); CHECKRETURN(1, SQL_HANDLE_STMT, cDatabase::m_hStmt, NULL)
retcode = SQLExecute( cDatabase::m_hStmt );
retcode = SQLBindCol( cDatabase::m_hStmt, 1, SQL_C_CHAR, OwnerIDBuff, sizeof( OwnerIDBuff ), NULL ); CHECKRETURN(1, SQL_HANDLE_STMT, cDatabase::m_hStmt, 1)
// Return SQL_SUCCESS if there is a house that corresponds to the hook's HouseID
if (SQLFetch( cDatabase::m_hStmt ) == SQL_SUCCESS) {
sscanf(OwnerIDBuff,"%08x",&OwnerID);
}
retcode = SQLCloseCursor( cDatabase::m_hStmt ); CHECKRETURN(0, SQL_HANDLE_STMT, cDatabase::m_hStmt, NULL)
retcode = SQLFreeStmt( cDatabase::m_hStmt, SQL_UNBIND );
float flpScale; // Scale used in Packet being Sent
float flmScale = 0; // Model Data Scale
DWORD dwFlags1 = 0x00009081; // Flags1
/*
dwModel
0x0A8D Floor Hook
0x0A8E Wall Hook
0x0A8C Ceiling Hook
0x0A8D Yard Hook
0x0A8D Roof Hook
wModelID
0x2DB1 Floor Hook
0x25D6 Wall Hook
0x2DB2 Ceiling Hook
0x3187 Yard Hook
0x3186 Roof Hook
wIconID
0x20C0
*/
WORD tBurden = 0;
if (IsUsed == 1)
{
// cItemModels *h_model = cItemModels::FindModel(m_hook_item->GetItemModelID());
// h_model->m_wBurden //Burden (WORD, no padding)
// tBurden += h_model->m_wBurden;
}
/*
//Loop through inventory and find all items.
for (int i = 0; i < this->m_hook_lstInventory.size(); i++)
{
//Find each item by it's GUID
cObject *v_item = this->FindInventory(this->v_guids[i]);
//Associate model with item
cItemModels *v_model = cItemModels::FindModel(v_item->GetItemModelID());
// v_item->GetGUID() //Item GUID
// v_model->m_dwFlags2 //10254018
// v_model->m_strName.c_str() //Item Name
// v_model->m_wModel //Model
// v_model->m_wIcon //Icon
// v_model->m_wBurden //Burden (WORD, no padding)
// v_model->m_wHooks; //Hook Type (WORD, no padding)
}
*/
cmCreate << 0xF745L
<< m_dwGUID
<< BYTE( 0x11 )
<< BYTE( 0 )
<< BYTE( 0 )
<< BYTE( 0 );
cmCreate << dwFlags1;
cmCreate << WORD(0x0014); // Type of portal
cmCreate << WORD(0x0000); // Unknown
//Flags1 Mask: 0x00009081
{
//Flags1 & 0x00008000 -- Location
cmCreate.pasteData( (UCHAR*)&m_Location, sizeof(m_Location) ); //Next comes the location
//Flags1 & 0x00001000 -- DWORD ResourceID
cmCreate << 0x3400002B; // unknown ResourceID
//Flags1 & 0x00000001 -- DWORD dwModel = 0x02000001; // the model.
DWORD dwModel = 0x02000000L + m_dwModel;
cmCreate << dwModel;
//Flags1 & 0x00000080 -- unknown_green
if (flmScale > 0)
{
flpScale = flmScale;// FLOAT flpScale
}
else
{
flpScale = 0.5;
}
cmCreate << flpScale;
}
// SeaGreens
WORD wUnkFlag2 = 0x0000;
WORD wUnkFlag3 = 0x0002;
WORD wUnkFlag4 = 0x0000;
WORD wUnkFlag6 = 0x0000;
WORD wUnkFlag7 = 0x0000;
WORD wUnkFlag8 = 0x0000;
WORD wUnkFlag10 = 0x0000;
cmCreate << m_wPositionSequence // movement 0x0001
<< wUnkFlag2 // animations
<< wUnkFlag3 // bubble modes
<< wUnkFlag4 // num jumps
<< m_wNumPortals
<< wUnkFlag6 // anim count
<< wUnkFlag7 // overrides
<< wUnkFlag8
<< WORD(0x7A51) // m_wNumLogins // 0x0D4B
<< wUnkFlag10;
DWORD dwFlags2 = 0x3220003A; // Flags2 -- Defines what data comes next
cmCreate << dwFlags2;
cmCreate << Name( ); // Object's Name
cmCreate << WORD(m_wModel) << WORD(m_wIcon);
DWORD dwObjectFlags1 = 0x00000200; // 0x0200 Containers
DWORD dwObjectFlags2 = 0x00000015; // 0x0010 is not an npc; 0x0004 cannot be picked up; 0x0001 can be opened (false if locked)
cmCreate << dwObjectFlags1 << dwObjectFlags2;
// Flags2 & 0x00000002 -- BYTE itemSlots
cmCreate << BYTE(0x01); // number of item slots
// Flags2 & 0x00000008 -- BYTE value
cmCreate << BYTE(0x0A); // object value
// Flags2 & 0x00000010 -- DWORD unknown10
cmCreate << 0x30000000L;
// Unknown
cmCreate << BYTE( 0 )
<< BYTE( 0 )
<< BYTE( 0 );
// Flags2 & 0x00000020 -- float approachDistance
float flApproach = 10.0f; // 0x41200000
cmCreate << flApproach; // distance a player will walk to use the object
// Flags2 & 0x00200000 -- WORD burden
tBurden += WORD(0x0005);
cmCreate << tBurden; // total burden of this object
// Flags2 & 0x02000000 -- ObjectID owner
cmCreate << OwnerID; // the owner of this object
// Flags2 & 0x20000000 -- hookType Unknown
cmCreate << WORD(0xFFFF); // always -1
// Flags2 & 0x10000000 -- hookable On
/*
0x0001 floor hook
0x0002 wall hook
0x0004 ceiling hook
0x0008 yard hook
0x0010 roof hook
*/
cmCreate << WORD(0xFFFF); // the types of hooks this object may be placed on (-1 for hooks)
return cmCreate;
}
bool reset_stmt(statement *stmt)
{
if (!SQL_SUCCEEDED(SQLFreeStmt(stmt->hstmt, SQL_RESET_PARAMS)))
return false;
return true;
}
STDMETHODIMP CComSpySqlAudit::Init(LPCWSTR pwszDSN, LPCWSTR pwszUser, LPCWSTR pwszPw)
{
WCHAR wszBuffer[1024];
SQLRETURN rc;
if (m_henv || m_hstmt || m_hdbc)
return E_UNEXPECTED; //did you call Init() twice?
rc = SQLAllocEnv( &m_henv );
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocEnv failed with code %d\n", rc);
goto Error;
}
//Allocate the Connection handle
rc = SQLAllocConnect( m_henv, &m_hdbc );
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocConnect failed with code %d\n", rc);
goto Error;
}
SQLSetConnectOption(m_hdbc, SQL_LOGIN_TIMEOUT, 5);
rc = SQLConnect( m_hdbc, SqlStringArg(pwszDSN), SQL_NTS,
SqlStringArg(pwszUser), SQL_NTS,
SqlStringArg(pwszPw), SQL_NTS);
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLConnect failed with code %d\n", rc);
goto Error;
}
//Allocate the statement handle
rc = SQLAllocStmt( m_hdbc, &m_hstmt);
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocStmt failed with code %d\n", rc);
goto Error;
}
//
// verify the table existence
//
{
for (int i=0; i < ARRAYSIZE(pwszTables); i++)
{
HRESULT hrString = StringCchPrintfEx(
wszBuffer, ARRAYSIZE(wszBuffer),
NULL, NULL, STRSAFE_NO_TRUNCATION,
L"CREATE TABLE dbo.%s (Ct int NOT NULL )", pwszTables[i]);
_ASSERTE(SUCCEEDED(hrString));
rc = SQLExecDirect(m_hstmt, SqlStringArg(wszBuffer), SQL_NTS);
if (SQL_SUCCEEDED(rc))
{
// this means the table is not in the db
//Clean up the table just created and exit
hrString = StringCchPrintfEx(wszBuffer, ARRAYSIZE(wszBuffer),
NULL, NULL, STRSAFE_NO_TRUNCATION,
L"drop table %s", pwszTables[i]);
_ASSERTE(SUCCEEDED(hrString));
rc = SQLExecDirect(m_hstmt, SqlStringArg(wszBuffer), SQL_NTS);
ATLTRACE(L"Table %s is not in the Database.\n", pwszTables[i]);
goto Error;
}
}
}
return S_OK;
Error:
if (m_hstmt)
{
SQLFreeStmt( m_hstmt, SQL_DROP );
}
if (m_hdbc)
{
rc = SQLDisconnect( m_hdbc);
SQLFreeConnect( m_hdbc);
if (m_henv)
SQLFreeEnv( m_henv );
}
m_hdbc = m_hstmt = m_henv = NULL;
return E_FAIL;
}
int
main (int argc, char *argv[])
{
if (argc < 4)
{
fprintf (stderr,
"ERR : called as setcurs <dsn> <uid> <pwd> [<scroll>=1]\n");
exit (-3);
}
rc = SQLAllocEnv (&henv);
if (rc != SQL_SUCCESS)
{
fprintf (stderr, "ERR : cannot alloc ODBC environment\n");
exit (-3);
}
rc = SQLAllocConnect (henv, &hdbc);
CHK_ERR (SQL_NULL_HSTMT);
rc = SQLConnect (hdbc, argv[1], SQL_NTS, argv[2], SQL_NTS, argv[3],
SQL_NTS);
CHK_ERR (SQL_NULL_HSTMT);
/* Allocate the statements and set the cursor name. */
rc = SQLAllocStmt (hdbc, &hstmtSelect);
CHK_ERR (SQL_NULL_HSTMT);
rc = SQLAllocStmt (hdbc, &hstmtUpdate);
CHK_ERR (SQL_NULL_HSTMT);
if (argc <= 4 || atoi (argv[4]) != 0)
{
rc = SQLSetStmtOption (hstmtSelect, SQL_CURSOR_TYPE, SQL_CURSOR_STATIC);
CHK_ERR (hstmtSelect);
rc = SQLSetScrollOptions (hstmtSelect, SQL_CONCUR_READ_ONLY, 1, 1);
CHK_ERR (hstmtSelect);
}
rc = SQLSetCursorName (hstmtSelect, "C1", SQL_NTS);
CHK_ERR (hstmtSelect);
/* SELECT the result set and bind its columns to local buffers. */
rc = SQLExecDirect (hstmtSelect, "SELECT NAME,PHONE from GOGO", SQL_NTS);
CHK_ERR (hstmtSelect);
rc = SQLBindCol (hstmtSelect, 1, SQL_C_CHAR, szName, NAME_LEN, &cbName);
CHK_ERR (hstmtSelect);
rc = SQLBindCol (hstmtSelect, 2, SQL_C_CHAR, szPhone, PHONE_LEN, &cbPhone);
CHK_ERR (hstmtSelect);
/* Read through the result set until the cursor is */
/* positioned on the row for John Smith. */
do
retcode = SQLFetch (hstmtSelect);
while ((retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) &&
(strcmp (szName, "Smith, John") != 0));
rc = retcode;
CHK_ERR (hstmtSelect);
/* Perform a positioned update of John Smith's name. */
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
{
rc = SQLExecDirect (hstmtUpdate,
"UPDATE GOGO SET PHONE='2064890154' WHERE CURRENT OF C1", SQL_NTS);
CHK_ERR (hstmtUpdate);
}
#if 0
SQLFreeStmt (hstmtUpdate, SQL_DROP);
SQLFreeStmt (hstmtSelect, SQL_DROP);
SQLDisconnect (hdbc);
SQLFreeConnect (hdbc);
#endif
printf ("PASSED: SetCursorName Test\n");
exit (0);
}
/*
---------------------------------------------------------
TestSQLProcedureColumns
---------------------------------------------------------
*/
PassFail TestMXSQLProcedureColumns(TestInfo *pTestInfo)
{
TEST_DECLARE;
TCHAR Heading[MAX_HEADING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ProcStr;
TCHAR ProcCatalog[NAME_LEN],ProcSchema[NAME_LEN],ProcName[NAME_LEN];
TCHAR ColName[NAME_LEN];
/* SEAQUEST */
char tmpbuf[1024];
TCHAR *myTestSch;
TCHAR *createSchStr;
TCHAR *setSchStr;
TCHAR *dropSchStr;
/* end of SEAQUEST */
TCHAR oProcCatalog[NAME_LEN];
TCHAR oProcSchema[NAME_LEN];
TCHAR oProcName[NAME_LEN];
TCHAR oColName[NAME_LEN];
SWORD oColType;
SWORD oColDataType;
TCHAR oColTypeName[NAME_LEN];
SDWORD oColSize;
SDWORD oBufferLen;
SWORD oDecDigits;
SWORD oColRadix;
SWORD oColNullable;
TCHAR oRemark[REM_LEN];
TCHAR oColDef[NAME_LEN];
SWORD oSQLDataType;
SWORD oSQLDateTimeSub;
SDWORD oCharOctetLen;
SDWORD oOrdinalPos;
TCHAR oIsNullable[NAME_LEN];
SQLLEN oProcCataloglen; // sushil
SQLLEN oProcSchemalen;
SQLLEN oProcNamelen;
SQLLEN oColNamelen;
SQLLEN oColTypelen;
SQLLEN oColDataTypelen;
SQLLEN oColTypeNamelen;
SQLLEN oColSizelen;
SQLLEN oBufferLenlen;
SQLLEN oDecDigitslen;
SQLLEN oColRadixlen;
SQLLEN oColNullablelen;
SQLLEN oRemarklen;
SQLLEN oColDeflen;
SQLLEN oSQLDataTypelen;
SQLLEN oSQLDateTimeSublen;
SQLLEN oCharOctetLenlen;
SQLLEN oOrdinalPoslen;
SQLLEN oIsNullablelen;
struct
{
TCHAR *DropProc;
TCHAR *CrtProc;
} CreateProc[] = {
{_T("DROP PROCEDURE N4210"),
_T("CREATE PROCEDURE N4210 (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4260"),
_T("CREATE PROCEDURE N4260 (IN IN1 REAL, INOUT INOUT1 INTEGER) EXTERNAL NAME 'Procs.N4260' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4261"),
_T("CREATE PROCEDURE N4261 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4261' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264"),
_T("CREATE PROCEDURE N4264 (IN IN1 VARCHAR(30) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264A"),
_T("CREATE PROCEDURE N4264A (IN IN1 CHAR(30) CHARACTER SET ISO88591, OUT OUT1 CHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264B"),
_T("CREATE PROCEDURE N4264B (IN IN1 VARCHAR(2000) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(2000) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264C"),
_T("CREATE PROCEDURE N4264C (IN IN1 VARCHAR(30) CHARACTER SET UCS2, OUT OUT1 VARCHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264D"),
_T("CREATE PROCEDURE N4264D (IN IN1 CHAR(30) CHARACTER SET UCS2, OUT OUT1 CHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264E"),
_T("CREATE PROCEDURE N4264E (IN IN1 VARCHAR(2000) CHARACTER SET UCS2, OUT OUT1 VARCHAR(2000) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4267"),
_T("CREATE PROCEDURE N4267 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4267' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("endloop"),_T("endloop")}
};
struct
{
TCHAR *ProcName;
TCHAR *ColName;
SWORD ColType;
SWORD ColDataType;
TCHAR *ColTypeName;
SDWORD ColSize;
SDWORD BufferLen;
SWORD DecDigits;
SWORD ColRadix;
SWORD ColNullable;
TCHAR *Remark;
TCHAR *ColDef;
SWORD SQLDataType;
SWORD SQLDateTimeSub;
SDWORD CharOctetLen;
SDWORD OrdinalPos;
TCHAR *IsNullable;
} ProcCol[] = {
/* {"N4210", "IN1", SQL_PARAM_INPUT, SQL_TYPE_TIME, "TIME", 8, 6, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 9, 2, <Null>, 1, "YES"},
{"N4260", "IN1", SQL_PARAM_INPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 1, "YES"},
{"N4260", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, "INTEGER SIGNED", 10, 4, 0, 10, SQL_NULLABLE, <Null>, <Null>, 4, <Null>, <Null>, 2, "YES"},
{"N4261", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"},
{"N4261", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"},
{"N4264", "IN1", SQL_PARAM_INPUT, SQL_WVARCHAR, "VARCHAR", 30, 30, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 30, 1, "YES"},
{"N4264", "OUT1", SQL_PARAM_OUTPUT, SQL_WVARCHAR, "VARCHAR", 45, 45, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 45, 2, "YES"},
{"N4267", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"},
{"N4267", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"},
*/
{_T("N4210"), _T("IN1"), SQL_PARAM_INPUT, SQL_TYPE_TIME, _T("TIME"), 8, 6, 0, 0, SQL_NULLABLE, _T(""), _T(""), 9, 2, 0, 1, _T("YES")},
{_T("N4260"), _T("IN1"), SQL_PARAM_INPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 1, _T("YES")},
{_T("N4260"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, _T("INTEGER SIGNED"),10, 4, 0, 10, SQL_NULLABLE, _T(""), _T(""), 4, 0, 0, 2, _T("YES")},
{_T("N4261"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")},
{_T("N4261"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")},
{_T("N4264"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 30,1, _T("YES")},
{_T("N4264"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 45,2, _T("YES")},
{_T("N4264A"), _T("IN1"), SQL_PARAM_INPUT, SQL_CHAR, _T("CHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 30,1, _T("YES")},
{_T("N4264A"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_CHAR, _T("CHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 45,2, _T("YES")},
{_T("N4264B"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,1, _T("YES")},
{_T("N4264B"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,2, _T("YES")},
{_T("N4264C"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 60,1, _T("YES")},
{_T("N4264C"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 90,2, _T("YES")},
{_T("N4264D"), _T("IN1"), SQL_PARAM_INPUT, SQL_WCHAR, _T("NCHAR"), 30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 60,1, _T("YES")},
{_T("N4264D"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WCHAR, _T("NCHAR"), 45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 90,2, _T("YES")},
{_T("N4264E"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,1, _T("YES")},
{_T("N4264E"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,2, _T("YES")},
{_T("N4267"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")},
{_T("N4267"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")},
{_T("endloop"),}
};
int i = 0, k = 0;
TCHAR State[STATE_SIZE];
SDWORD NativeError;
TCHAR buf[MAX_STRING_SIZE];
//TCHAR *charNameUCS2 = _T("NCHAR");
//TCHAR *varcharNameUCS2 = _T("NCHAR VARYING");
LogMsg(SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLProcedureColumns.\n"));
//=================================================================================================
//if(isUCS2) {
// LogMsg(LINEBEFORE,_T("Setup for UCS2 mode testing: ColSize,BufferLen and CharOctetlen has to be doubled\n"));
// k = sizeof(ProcCol)/sizeof(ProcCol[0]);
// while(i < k) {
// if(ProcCol[i].ColDataType == SQL_WCHAR)
// {
// ProcCol[i].ColDataType = SQL_WCHAR;
// ProcCol[i].SQLDataType = SQL_WCHAR;
// ProcCol[i].ColTypeName = charNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else if (ProcCol[i].ColDataType == SQL_WVARCHAR)
// {
// ProcCol[i].ColDataType = SQL_WVARCHAR;
// ProcCol[i].SQLDataType = SQL_WVARCHAR;
// ProcCol[i].ColTypeName = varcharNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else if (ProcCol[i].ColDataType == SQL_WLONGVARCHAR)
// {
// ProcCol[i].ColDataType = SQL_WLONGVARCHAR;
// ProcCol[i].SQLDataType = SQL_WLONGVARCHAR;
// ProcCol[i].ColTypeName = varcharNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else {}
// i++;
// }
// i = 0;
// k = 0;
//}
//=================================================================================================
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLProcedureColumns tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,_T("Unable to connect\n"));
//TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect3(pTestInfo);
//TEST_FAILED;
TEST_RETURN;
}
//TESTCASE_END;
ProcStr = (TCHAR *)malloc(MAX_NOS_SIZE);
/* SEAQUEST */
myTestSch = (TCHAR *)malloc(MAX_NOS_SIZE);
createSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
setSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
dropSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
_tcscpy (myTestSch, _T("ODBC_PROCCOL_TEST"));
_tcscpy (createSchStr, _T("create schema "));
_tcscat (createSchStr, pTestInfo->Catalog);
_tcscat (createSchStr, _T("."));
_tcscat (createSchStr, myTestSch);
_tcscpy (setSchStr, _T("set schema "));
_tcscat (setSchStr, pTestInfo->Catalog);
_tcscat (setSchStr, _T("."));
_tcscat (setSchStr, myTestSch);
_tcscpy (dropSchStr, _T("drop schema "));
_tcscat (dropSchStr, pTestInfo->Catalog);
_tcscat (dropSchStr, _T("."));
_tcscat (dropSchStr, myTestSch);
_tcscat (dropSchStr, _T(" cascade"));
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS);
// if(!CHECKRC(SQL_SUCCESS,returncode,"Drop Schema"))
// {
// TEST_FAILED;
// LogAllErrors(henv,hdbc,hstmt);
// }
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) createSchStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"Create Schema"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) setSchStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"Set Schema"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
/* end of SEAQUEST */
while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0)
{
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].DropProc);
SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].CrtProc);
_stprintf(Heading,_T("Adding Procedure => "));
_tcscat(Heading,ProcStr);
_tcscat(Heading,_T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ProcStr,SQL_NTS);
if(returncode != SQL_SUCCESS)
{
returncode = SQLError((SQLHANDLE)NULL, (SQLHANDLE)NULL, hstmt, (SQLTCHAR*)State, &NativeError, (SQLTCHAR*)buf, MAX_STRING_SIZE, NULL);
if (NativeError == -2013)
{
LogMsg(NONE, _T("Stored Procedures not supported\n"));
_gTestCount--;
free(ProcStr);
FullDisconnect(pTestInfo);
LogMsg(SHORTTIMESTAMP,_T("End testing API => MX Specific SQLProcedureColumns.\n"));
TEST_RETURN;
}
else
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
}
TESTCASE_END;
i++;
}
_tcscpy(ProcCatalog, pTestInfo->Catalog);
_tcscpy(ProcSchema, myTestSch /*SEAQUEST pTestInfo->Schema*/);
_stprintf(Heading,_T("Test Positive Functionality of SQLProcedureColumns \n"));
TESTCASE_BEGINW(Heading);
returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch/* SEAQUEST pTestInfo->Schema*/,(SWORD)_tcslen(myTestSch/* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR *)_T("%"),(SWORD)1,(SQLTCHAR *)_T("%"),(SWORD)1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLProcedureColumns"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
if (returncode == SQL_SUCCESS)
{
_tcscpy(oProcCatalog,_T(""));
_tcscpy(oProcSchema,_T(""));
_tcscpy(oProcName,_T(""));
_tcscpy(oColName,_T(""));
oColType = 0;
oColDataType = 0;
_tcscpy(oColTypeName,_T(""));
oColSize = 0;
oBufferLen = 0;
oDecDigits = 0;
oColRadix = 0;
oColNullable = 0;
_tcscpy(oRemark,_T(""));
_tcscpy(oColDef,_T(""));
oSQLDataType = 0;
oSQLDateTimeSub = 0;
oCharOctetLen = 0;
oOrdinalPos = 0;
_tcscpy(oIsNullable,_T(""));
SQLBindCol(hstmt,1,SQL_C_TCHAR,oProcCatalog,NAME_LEN,&oProcCataloglen);
SQLBindCol(hstmt,2,SQL_C_TCHAR,oProcSchema,NAME_LEN,&oProcSchemalen);
SQLBindCol(hstmt,3,SQL_C_TCHAR,oProcName,NAME_LEN,&oProcNamelen);
SQLBindCol(hstmt,4,SQL_C_TCHAR,oColName,NAME_LEN,&oColNamelen);
SQLBindCol(hstmt,5,SQL_C_SHORT,&oColType,0,&oColTypelen);
SQLBindCol(hstmt,6,SQL_C_SHORT,&oColDataType,0,&oColDataTypelen);
SQLBindCol(hstmt,7,SQL_C_TCHAR,oColTypeName,NAME_LEN,&oColTypeNamelen);
SQLBindCol(hstmt,8,SQL_C_LONG,&oColSize,0,&oColSizelen);
SQLBindCol(hstmt,9,SQL_C_LONG,&oBufferLen,0,&oBufferLenlen);
SQLBindCol(hstmt,10,SQL_C_SHORT,&oDecDigits,0,&oDecDigitslen);
SQLBindCol(hstmt,11,SQL_C_SHORT,&oColRadix,0,&oColRadixlen);
SQLBindCol(hstmt,12,SQL_C_SHORT,&oColNullable,0,&oColNullablelen);
SQLBindCol(hstmt,13,SQL_C_TCHAR,oRemark,REM_LEN,&oRemarklen);
SQLBindCol(hstmt,14,SQL_C_TCHAR,oColDef,NAME_LEN,&oColDeflen);
SQLBindCol(hstmt,15,SQL_C_SHORT,&oSQLDataType,0,&oSQLDataTypelen);
SQLBindCol(hstmt,16,SQL_C_SHORT,&oSQLDateTimeSub,0,&oSQLDateTimeSublen);
SQLBindCol(hstmt,17,SQL_C_LONG,&oCharOctetLen,0,&oCharOctetLenlen);
SQLBindCol(hstmt,18,SQL_C_LONG,&oOrdinalPos,0,&oOrdinalPoslen);
SQLBindCol(hstmt,19,SQL_C_TCHAR,oIsNullable,NAME_LEN,&oIsNullablelen);
k = 0;
i = 0;
while (returncode == SQL_SUCCESS)
{
if(_tcscmp(ProcCol[i].ProcName,_T("endloop")) == 0)
break;
returncode = SQLFetch(hstmt);
if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS)
{
k++;
_stprintf(Heading,_T("SQLProcedureColumns: Comparing Results\n"));
TESTCASE_BEGINW(Heading);
if ((_tcsicmp(ProcCatalog,oProcCatalog) == 0)
&& (_tcsicmp(ProcSchema,oProcSchema) == 0)
&& (_tcsicmp(ProcCol[i].ProcName,oProcName) == 0)
&& (_tcsicmp(ProcCol[i].ColName,oColName) == 0)
&& (ProcCol[i].ColType == oColType)
&& (ProcCol[i].ColDataType == oColDataType)
&& (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) == 0)
&& (ProcCol[i].ColSize == oColSize)
&& (ProcCol[i].BufferLen == oBufferLen)
&& (ProcCol[i].DecDigits == oDecDigits)
&& (ProcCol[i].ColRadix == oColRadix)
&& (ProcCol[i].ColNullable == oColNullable)
&& (_tcsicmp(ProcCol[i].Remark,oRemark) == 0)
&& (_tcsicmp(ProcCol[i].ColDef,oColDef) == 0)
&& (ProcCol[i].SQLDataType == oSQLDataType)
&& (ProcCol[i].SQLDateTimeSub == oSQLDateTimeSub)
&& (ProcCol[i].CharOctetLen == oCharOctetLen)
&& (ProcCol[i].OrdinalPos == oOrdinalPos)
&& (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) == 0)){
LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog);
LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema);
LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName);
LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName);
LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType);
LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType);
LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName);
LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize);
LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen);
LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits);
LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix);
LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable);
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark);
LogMsg(NONE,_T("ColDef expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef);
LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable);
}
else
{
TEST_FAILED;
if (_tcsicmp(ProcCatalog,oProcCatalog) != 0)
LogMsg(ERRMSG,_T("ProcCatalog expect: %s and actual: %s are not matched\n"),ProcCatalog,oProcCatalog);
else
LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog);
if (_tcsicmp(ProcSchema,oProcSchema) != 0)
LogMsg(ERRMSG,_T("ProcSchema expect: %s and actual: %s are not matched\n"),ProcSchema,oProcSchema);
else
LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema);
if (_tcsicmp(ProcCol[i].ProcName,oProcName) != 0)
LogMsg(ERRMSG,_T("ProcName expect: %s and actual: %s are not matched\n"),ProcCol[i].ProcName,oProcName);
else
LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName);
if (_tcsicmp(ProcCol[i].ColName,oColName) != 0)
LogMsg(ERRMSG,_T("ColName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColName,oColName);
else
LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName);
if (ProcCol[i].ColType != oColType)
LogMsg(ERRMSG,_T("ColType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColType,oColType);
else
LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType);
if (ProcCol[i].ColDataType != oColDataType)
LogMsg(ERRMSG,_T("ColDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColDataType,oColDataType);
else
LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType);
if (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) != 0)
LogMsg(ERRMSG,_T("ColTypeName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColTypeName,oColTypeName);
else
LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName);
if (ProcCol[i].ColSize != oColSize)
LogMsg(ERRMSG,_T("ColSize expect: %d and actual: %d are not matched\n"),ProcCol[i].ColSize,oColSize);
else
LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize);
if (ProcCol[i].BufferLen != oBufferLen)
LogMsg(ERRMSG,_T("BufferLen expect: %d and actual: %d are not matched\n"),ProcCol[i].BufferLen,oBufferLen);
else
LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen);
if (ProcCol[i].DecDigits != oDecDigits)
LogMsg(ERRMSG,_T("DecDigits expect: %d and actual: %d are not matched\n"),ProcCol[i].DecDigits,oDecDigits);
else
LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits);
if (ProcCol[i].ColRadix != oColRadix)
LogMsg(ERRMSG,_T("ColRadix expect: %d and actual: %d are not matched\n"),ProcCol[i].ColRadix,oColRadix);
else
LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix);
if (ProcCol[i].ColNullable != oColNullable)
LogMsg(ERRMSG,_T("ColNullable expect: %d and actual: %d are not matched\n"),ProcCol[i].ColNullable,oColNullable);
else
LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable);
if (_tcsicmp(ProcCol[i].Remark,oRemark) != 0)
LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].Remark,oRemark);
else
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark);
if (_tcsicmp(ProcCol[i].ColDef,oColDef) != 0)
LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].ColDef,oColDef);
else
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef);
if (ProcCol[i].SQLDataType != oSQLDataType)
LogMsg(ERRMSG,_T("SQLDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
else
LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
if (ProcCol[i].SQLDateTimeSub != oSQLDateTimeSub)
LogMsg(ERRMSG,_T("SQLDateTimeSub expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
else
LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
if (ProcCol[i].CharOctetLen != oCharOctetLen)
LogMsg(ERRMSG,_T("CharOctetLen expect: %d and actual: %d are not matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
else
LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
if (ProcCol[i].OrdinalPos != oOrdinalPos)
LogMsg(ERRMSG,_T("OrdinalPos expect: %d and actual: %d are not matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
else
LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
if (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) != 0)
LogMsg(ERRMSG,_T("IsNullable expect: %s and actual: %s are not matched\n"),ProcCol[i].IsNullable,oIsNullable);
else
LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable);
}
}
}
if(k == 0)
{
TEST_FAILED;
LogMsg(ERRMSG,_T("No Data Found => Atleast one row should be fetched\n"));
}
TESTCASE_END;
_tcscpy(oProcCatalog,_T(""));
_tcscpy(oProcSchema,_T(""));
_tcscpy(oProcName,_T(""));
_tcscpy(oColName,_T(""));
oColType = 0;
oColDataType = 0;
_tcscpy(oColTypeName,_T(""));
oColSize = 0;
oBufferLen = 0;
oDecDigits = 0;
oColRadix = 0;
oColNullable = 0;
_tcscpy(oRemark,_T(""));
_tcscpy(oColDef,_T(""));
oSQLDataType = 0;
oSQLDateTimeSub = 0;
oCharOctetLen = 0;
oOrdinalPos = 0;
_tcscpy(oIsNullable,_T(""));
i++;
} // while
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
i=0;
while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0)
{
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].DropProc);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
i++;
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
//========================================================================================================
_stprintf(Heading,_T("SQLProcedureColumns: Negative test with NULL handle\n"));
TESTCASE_BEGINW(Heading);
hstmt = (SQLHANDLE)NULL;
_tcscpy(ProcName,_T("junkproc"));
_tcscpy(ColName,_T("C1"));
returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch /* SEAQUEST pTestInfo->Schema */,(SWORD)_tcslen(myTestSch /* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR*)ProcName,(SWORD)_tcslen(ProcName),(SQLTCHAR*)ColName,(SWORD)_tcslen(ColName));
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLProcedureColumns"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//========================================================================================================
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS);
free(ProcStr);
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLProcedureColumns.\n"));
TEST_RETURN;
}
void RecvCMD_SET_COMMANDER(t_packet *p, t_connection c[], int cn ) // 사령관의 데이터를 세트한다.
{
NW_Character tempNWCharacter;
DWORD tempDWORD;
HSTMT hStmt=NULL;
RETCODE ret;
SWORD nClos;
char query_stmt[80]={0,};
SDWORD cbValue;
SQLAllocStmt(hDBC,&hStmt);
wsprintf(query_stmt,"select fame_pk from chr_info where name='%s'",p->u.NationWar.SetCommander.CommanderName);
ret = SQLExecDirect(hStmt,(UCHAR*)query_stmt,SQL_NTS);
if (ret!=SQL_SUCCESS_WITH_INFO && ret !=SQL_SUCCESS)
{
MyLog(0,"Query Failure!! RecvCMD_SET_COMMANDER..");
SQLFreeStmt(hStmt,SQL_DROP);
return;
}
SQLNumResultCols(hStmt,&nClos);
ret=SQLFetch(hStmt);
if (ret!=SQL_SUCCESS_WITH_INFO && ret !=SQL_SUCCESS)
{
//MyLog(0,"WarField Fetch Error!!");
SQLFreeStmt(hStmt,SQL_DROP);
return ;
}
ret=SQLGetData(hStmt,1,SQL_C_SLONG,&tempDWORD,sizeof(int),&cbValue);
if (ret!=SQL_SUCCESS_WITH_INFO && ret!=SQL_SUCCESS)
{
MyLog(0,"SQL Return Error(%d)!!",ret);
SQLFreeStmt(hStmt,SQL_DROP);
return ;
}
SQLFreeStmt(hStmt,SQL_DROP);
memcpy(&tempNWCharacter,&tempDWORD,sizeof(DWORD));
tempNWCharacter.isCommander=1;
memcpy(&tempDWORD,&tempNWCharacter,sizeof(DWORD));
memcpy(&tempNWCharacter,&tempDWORD,sizeof(DWORD));
SQLAllocStmt(hDBC,&hStmt);
wsprintf(query_stmt,"update chr_info set fame_pk=%d where name='%s'",tempDWORD,p->u.NationWar.SetCommander.CommanderName);
ret=SQLExecDirect(hStmt,(UCHAR*)query_stmt,SQL_NTS);
if (ret!=SQL_SUCCESS_WITH_INFO && ret!=SQL_SUCCESS)
{
MyLog(0,"Update Query Failure!! RecvCMD_SET_COMMANDER..");
SQLFreeStmt(hStmt,SQL_DROP);
return;
}
SQLFreeStmt(hStmt,SQL_DROP);
}
static void
DoTest(int version3)
{
char name[128], params[128];
SQLSMALLINT type, is_unsigned;
SQLINTEGER col_size, min_scale;
SQLLEN ind1, ind2, ind3, ind4, ind5, ind6;
int date_time_supported = 0;
int name_version3;
odbc_use_version3 = version3;
name_version3 = version3;
odbc_connect();
printf("Using ODBC version %d\n", version3 ? 3 : 2);
/* test column name */
/* MS ODBC use always ODBC 3 names even in ODBC 2 mode */
if (!odbc_driver_is_freetds())
name_version3 = 1;
CHKGetTypeInfo(SQL_ALL_TYPES, "SI");
TestName(1, "TYPE_NAME");
TestName(2, "DATA_TYPE");
TestName(3, name_version3 ? "COLUMN_SIZE" : "PRECISION");
TestName(4, "LITERAL_PREFIX");
TestName(5, "LITERAL_SUFFIX");
TestName(6, "CREATE_PARAMS");
TestName(7, "NULLABLE");
TestName(8, "CASE_SENSITIVE");
TestName(9, "SEARCHABLE");
TestName(10, "UNSIGNED_ATTRIBUTE");
TestName(11, name_version3 ? "FIXED_PREC_SCALE" : "MONEY");
TestName(12, name_version3 ? "AUTO_UNIQUE_VALUE" : "AUTO_INCREMENT");
TestName(13, "LOCAL_TYPE_NAME");
TestName(14, "MINIMUM_SCALE");
TestName(15, "MAXIMUM_SCALE");
/* TODO test these column for ODBC 3 */
/* ODBC 3.0 SQL_DATA_TYPE SQL_DATETIME_SUB NUM_PREC_RADIX INTERVAL_PRECISION */
Flushodbc_stmt();
/* TODO test if SQL_ALL_TYPES returns right numeric type for timestamp */
/* numeric type for data */
/* test for date/time support */
if (odbc_command_with_result(odbc_stmt, "select cast(getdate() as date)") == SQL_SUCCESS)
date_time_supported = 1;
SQLCloseCursor(odbc_stmt);
#define CHECK_TYPE(in,out) CheckType(in, out, #in, __LINE__)
/* under Sybase this type require extra handling, check it */
CHECK_TYPE(SQL_VARCHAR, SQL_VARCHAR);
CHECK_TYPE(SQL_DATE, date_time_supported && !version3 ? SQL_DATE : SQL_UNKNOWN_TYPE);
CHECK_TYPE(SQL_TIME, date_time_supported && !version3 ? SQL_TIME : SQL_UNKNOWN_TYPE);
/* MS ODBC returns S1004 (HY004), TODO support it */
if (odbc_driver_is_freetds() || version3) {
CHECK_TYPE(SQL_TYPE_DATE, date_time_supported && version3 ? SQL_TYPE_DATE : SQL_UNKNOWN_TYPE);
CHECK_TYPE(SQL_TYPE_TIME, date_time_supported && version3 ? SQL_TYPE_TIME : SQL_UNKNOWN_TYPE);
}
/* TODO MS ODBC handle SQL_TIMESTAMP even for ODBC 3 */
if (odbc_driver_is_freetds())
CHECK_TYPE(SQL_TIMESTAMP, version3 ? SQL_UNKNOWN_TYPE : SQL_TIMESTAMP);
else
CHECK_TYPE(SQL_TIMESTAMP, version3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP);
/* MS ODBC returns S1004 (HY004), TODO support it */
if (odbc_driver_is_freetds() || version3) {
CHECK_TYPE(SQL_TYPE_TIMESTAMP, version3 ? SQL_TYPE_TIMESTAMP : SQL_UNKNOWN_TYPE);
}
/* TODO implement this part of test */
/* varchar/nvarchar before sysname */
/* test binding (not all column, required for Oracle) */
CHKGetTypeInfo(SQL_ALL_TYPES, "SI");
CHKBindCol(1, SQL_C_CHAR, name, sizeof(name), &ind1, "SI");
CHKBindCol(2, SQL_C_SSHORT, &type, 0, &ind2, "SI");
CHKBindCol(3, SQL_C_SLONG, &col_size, 0, &ind3, "SI");
CHKBindCol(6, SQL_C_CHAR, params, sizeof(params), &ind4, "SI");
CHKBindCol(10, SQL_C_SSHORT, &is_unsigned, 0, &ind5, "SI");
CHKBindCol(14, SQL_C_SSHORT, &min_scale, 0, &ind6, "SI");
while (CHKFetch("SNo") == SQL_SUCCESS)
;
SQLFreeStmt(odbc_stmt, SQL_UNBIND);
Flushodbc_stmt();
/* check WVARCHAR for no pending data */
if (odbc_db_is_microsoft() || strncmp(odbc_db_version(), "15.00.", 6) >= 0) {
CHKGetTypeInfo(SQL_WVARCHAR, "SI");
CHKFetch("S");
if (odbc_db_is_microsoft())
CHKFetch("S");
CHKFetch("No");
CHKGetTypeInfo(SQL_BINARY, "SI");
}
odbc_disconnect();
}
int main(int argc, char **argv)
{
SQLRETURN rc;
HSTMT hstmt = SQL_NULL_HSTMT;
char param1[20] = { 1, 2, 3, 4, 5, 6, 7, 8 };
SQLLEN cbParam1;
SQLSMALLINT colcount;
SQLSMALLINT dataType;
SQLULEN paramSize;
SQLSMALLINT decDigits;
SQLSMALLINT nullable;
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);
}
/**** Query with a bytea param ****/
/* Prepare a statement */
rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM byteatab WHERE t = ?", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt);
/* bind param */
cbParam1 = 8;
rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_BINARY, /* value type */
SQL_BINARY, /* param type */
20, /* column size */
0, /* dec digits */
param1, /* param value ptr */
0, /* buffer len */
&cbParam1 /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
/* Test SQLNumResultCols, called before SQLExecute() */
rc = SQLNumResultCols(hstmt, &colcount);
CHECK_STMT_RESULT(rc, "SQLNumResultCols failed", hstmt);
printf("# of result cols: %d\n", colcount);
/* Execute */
rc = SQLExecute(hstmt);
CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt);
/* Fetch result */
print_result(hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/*** Test SQLBindParameter with SQLExecDirect ***/
printf("\nTesting SQLBindParameter with SQLExecDirect...\n");
/* bind param */
strcpy(param1, "bar");
cbParam1 = SQL_NTS;
rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_CHAR, /* value type */
SQL_CHAR, /* param type */
20, /* column size */
0, /* dec digits */
param1, /* param value ptr */
0, /* buffer len */
&cbParam1 /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT 'foo' UNION ALL SELECT ?", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
print_result(hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/*** Test SQLDescribeParam ***/
printf("\nTesting SQLDescribeParam...\n");
rc = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/* Prepare a statement */
rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM testtab1 WHERE id = ?", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt);
rc = SQLDescribeParam(hstmt, 1, &dataType, ¶mSize, &decDigits, &nullable);
CHECK_STMT_RESULT(rc, "SQLDescribeParams failed", hstmt);
printf("Param 1: type %s; size %u; dec digits %d; %s\n",
datatype_str(dataType), (unsigned int) paramSize, decDigits, nullable_str(nullable));
/* bind param */
strcpy(param1, "3");
cbParam1 = SQL_NTS;
rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_CHAR, /* value type */
SQL_CHAR, /* param type */
20, /* column size */
0, /* dec digits */
param1, /* param value ptr */
0, /* buffer len */
&cbParam1 /* StrLen_or_IndPtr */);
CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt);
/* Test SQLNumResultCols, called before SQLExecute() */
rc = SQLNumResultCols(hstmt, &colcount);
CHECK_STMT_RESULT(rc, "SQLNumResultCols failed", hstmt);
printf("# of result cols: %d\n", colcount);
/* Execute */
rc = SQLExecute(hstmt);
CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt);
/* Fetch result */
print_result(hstmt);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
/* Clean up */
test_disconnect();
return 0;
}
void
tw_close (t1_window_t * tw)
{
SQLFreeStmt (tw->tw_stmt, SQL_DROP);
tw->tw_stmt = SQL_NULL_HSTMT;
}
static int
backsql_get_attr_vals( void *v_at, void *v_bsi )
{
backsql_at_map_rec *at = v_at;
backsql_srch_info *bsi = v_bsi;
backsql_info *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
RETCODE rc;
SQLHSTMT sth = SQL_NULL_HSTMT;
BACKSQL_ROW_NTS row;
unsigned long i,
k = 0,
oldcount = 0,
res = 0;
#ifdef BACKSQL_COUNTQUERY
unsigned count,
j,
append = 0;
SQLLEN countsize = sizeof( count );
Attribute *attr = NULL;
slap_mr_normalize_func *normfunc = NULL;
#endif /* BACKSQL_COUNTQUERY */
#ifdef BACKSQL_PRETTY_VALIDATE
slap_syntax_validate_func *validate = NULL;
slap_syntax_transform_func *pretty = NULL;
#endif /* BACKSQL_PRETTY_VALIDATE */
assert( at != NULL );
assert( bsi != NULL );
#ifdef BACKSQL_ARBITRARY_KEY
Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(): "
"oc=\"%s\" attr=\"%s\" keyval=%s\n",
BACKSQL_OC_NAME( bsi->bsi_oc ), at->bam_ad->ad_cname.bv_val,
bsi->bsi_c_eid->eid_keyval.bv_val );
#else /* ! BACKSQL_ARBITRARY_KEY */
Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(): "
"oc=\"%s\" attr=\"%s\" keyval=%ld\n",
BACKSQL_OC_NAME( bsi->bsi_oc ), at->bam_ad->ad_cname.bv_val,
bsi->bsi_c_eid->eid_keyval );
#endif /* ! BACKSQL_ARBITRARY_KEY */
#ifdef BACKSQL_PRETTY_VALIDATE
validate = at->bam_true_ad->ad_type->sat_syntax->ssyn_validate;
pretty = at->bam_true_ad->ad_type->sat_syntax->ssyn_pretty;
if ( validate == NULL && pretty == NULL ) {
return 1;
}
#endif /* BACKSQL_PRETTY_VALIDATE */
#ifdef BACKSQL_COUNTQUERY
if ( at->bam_true_ad->ad_type->sat_equality ) {
normfunc = at->bam_true_ad->ad_type->sat_equality->smr_normalize;
}
/* Count how many rows will be returned. This avoids memory
* fragmentation that can result from loading the values in
* one by one and using realloc()
*/
rc = backsql_Prepare( bsi->bsi_dbh, &sth, at->bam_countquery, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error preparing count query: %s\n",
at->bam_countquery, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
return 1;
}
rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT,
&bsi->bsi_c_eid->eid_keyval );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error binding key value parameter\n", 0, 0, 0 );
SQLFreeStmt( sth, SQL_DROP );
return 1;
}
rc = SQLExecute( sth );
if ( ! BACKSQL_SUCCESS( rc ) ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error executing attribute count query '%s'\n",
at->bam_countquery, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
return 1;
}
SQLBindCol( sth, (SQLUSMALLINT)1, SQL_C_LONG,
(SQLPOINTER)&count,
(SQLINTEGER)sizeof( count ),
&countsize );
rc = SQLFetch( sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error fetch results of count query: %s\n",
at->bam_countquery, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
return 1;
}
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"number of values in query: %u\n", count, 0, 0 );
SQLFreeStmt( sth, SQL_DROP );
if ( count == 0 ) {
return 1;
}
attr = attr_find( bsi->bsi_e->e_attrs, at->bam_true_ad );
if ( attr != NULL ) {
BerVarray tmp;
if ( attr->a_vals != NULL ) {
oldcount = attr->a_numvals;
}
tmp = ch_realloc( attr->a_vals, ( oldcount + count + 1 ) * sizeof( struct berval ) );
if ( tmp == NULL ) {
return 1;
}
attr->a_vals = tmp;
memset( &attr->a_vals[ oldcount ], 0, ( count + 1 ) * sizeof( struct berval ) );
if ( normfunc ) {
tmp = ch_realloc( attr->a_nvals, ( oldcount + count + 1 ) * sizeof( struct berval ) );
if ( tmp == NULL ) {
return 1;
}
attr->a_nvals = tmp;
memset( &attr->a_nvals[ oldcount ], 0, ( count + 1 ) * sizeof( struct berval ) );
} else {
attr->a_nvals = attr->a_vals;
}
attr->a_numvals += count;
} else {
append = 1;
/* Make space for the array of values */
attr = attr_alloc( at->bam_true_ad );
attr->a_numvals = count;
attr->a_vals = ch_calloc( count + 1, sizeof( struct berval ) );
if ( attr->a_vals == NULL ) {
Debug( LDAP_DEBUG_TRACE, "Out of memory!\n", 0,0,0 );
ch_free( attr );
return 1;
}
if ( normfunc ) {
attr->a_nvals = ch_calloc( count + 1, sizeof( struct berval ) );
if ( attr->a_nvals == NULL ) {
ch_free( attr->a_vals );
ch_free( attr );
return 1;
}
} else {
attr->a_nvals = attr->a_vals;
}
}
#endif /* BACKSQL_COUNTQUERY */
rc = backsql_Prepare( bsi->bsi_dbh, &sth, at->bam_query, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error preparing query: %s\n", at->bam_query, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
#ifdef BACKSQL_COUNTQUERY
if ( append ) {
attr_free( attr );
}
#endif /* BACKSQL_COUNTQUERY */
return 1;
}
rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT,
&bsi->bsi_c_eid->eid_keyval );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error binding key value parameter\n", 0, 0, 0 );
#ifdef BACKSQL_COUNTQUERY
if ( append ) {
attr_free( attr );
}
#endif /* BACKSQL_COUNTQUERY */
return 1;
}
#ifdef BACKSQL_TRACE
#ifdef BACKSQL_ARBITRARY_KEY
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"query=\"%s\" keyval=%s\n", at->bam_query,
bsi->bsi_c_eid->eid_keyval.bv_val, 0 );
#else /* !BACKSQL_ARBITRARY_KEY */
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"query=\"%s\" keyval=%d\n", at->bam_query,
bsi->bsi_c_eid->eid_keyval, 0 );
#endif /* ! BACKSQL_ARBITRARY_KEY */
#endif /* BACKSQL_TRACE */
rc = SQLExecute( sth );
if ( ! BACKSQL_SUCCESS( rc ) ) {
Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): "
"error executing attribute query \"%s\"\n",
at->bam_query, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
#ifdef BACKSQL_COUNTQUERY
if ( append ) {
attr_free( attr );
}
#endif /* BACKSQL_COUNTQUERY */
return 1;
}
backsql_BindRowAsStrings_x( sth, &row, bsi->bsi_op->o_tmpmemctx );
#ifdef BACKSQL_COUNTQUERY
j = oldcount;
#endif /* BACKSQL_COUNTQUERY */
for ( rc = SQLFetch( sth ), k = 0;
BACKSQL_SUCCESS( rc );
rc = SQLFetch( sth ), k++ )
{
for ( i = 0; i < (unsigned long)row.ncols; i++ ) {
if ( row.value_len[ i ] > 0 ) {
struct berval bv;
int retval;
#ifdef BACKSQL_TRACE
AttributeDescription *ad = NULL;
const char *text;
retval = slap_bv2ad( &row.col_names[ i ], &ad, &text );
if ( retval != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"==>backsql_get_attr_vals(\"%s\"): "
"unable to find AttributeDescription %s "
"in schema (%d)\n",
bsi->bsi_e->e_name.bv_val,
row.col_names[ i ].bv_val, retval );
res = 1;
goto done;
}
if ( ad != at->bam_ad ) {
Debug( LDAP_DEBUG_ANY,
"==>backsql_get_attr_vals(\"%s\"): "
"column name %s differs from "
"AttributeDescription %s\n",
bsi->bsi_e->e_name.bv_val,
ad->ad_cname.bv_val,
at->bam_ad->ad_cname.bv_val );
res = 1;
goto done;
}
#endif /* BACKSQL_TRACE */
/* ITS#3386, ITS#3113 - 20070308
* If a binary is fetched?
* must use the actual size read
* from the database.
*/
if ( BACKSQL_IS_BINARY( row.col_type[ i ] ) ) {
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_ANY,
"==>backsql_get_attr_vals(\"%s\"): "
"column name %s: data is binary; "
"using database size %ld\n",
bsi->bsi_e->e_name.bv_val,
ad->ad_cname.bv_val,
row.value_len[ i ] );
#endif /* BACKSQL_TRACE */
bv.bv_val = row.cols[ i ];
bv.bv_len = row.value_len[ i ];
} else {
ber_str2bv( row.cols[ i ], 0, 0, &bv );
}
#ifdef BACKSQL_PRETTY_VALIDATE
if ( pretty ) {
struct berval pbv;
retval = pretty( at->bam_true_ad->ad_type->sat_syntax,
&bv, &pbv, bsi->bsi_op->o_tmpmemctx );
bv = pbv;
} else {
retval = validate( at->bam_true_ad->ad_type->sat_syntax,
&bv );
}
if ( retval != LDAP_SUCCESS ) {
char buf[ SLAP_TEXT_BUFLEN ];
/* FIXME: we're ignoring invalid values,
* but we're accepting the attributes;
* should we fail at all? */
snprintf( buf, sizeof( buf ),
"unable to %s value #%lu "
"of AttributeDescription %s",
pretty ? "prettify" : "validate",
k - oldcount,
at->bam_ad->ad_cname.bv_val );
Debug( LDAP_DEBUG_TRACE,
"==>backsql_get_attr_vals(\"%s\"): "
"%s (%d)\n",
bsi->bsi_e->e_name.bv_val, buf, retval );
continue;
}
#endif /* BACKSQL_PRETTY_VALIDATE */
#ifndef BACKSQL_COUNTQUERY
(void)backsql_entry_addattr( bsi->bsi_e,
at->bam_true_ad, &bv,
bsi->bsi_op->o_tmpmemctx );
#else /* BACKSQL_COUNTQUERY */
if ( normfunc ) {
struct berval nbv;
retval = (*normfunc)( SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
at->bam_true_ad->ad_type->sat_syntax,
at->bam_true_ad->ad_type->sat_equality,
&bv, &nbv,
bsi->bsi_op->o_tmpmemctx );
if ( retval != LDAP_SUCCESS ) {
char buf[ SLAP_TEXT_BUFLEN ];
/* FIXME: we're ignoring invalid values,
* but we're accepting the attributes;
* should we fail at all? */
snprintf( buf, sizeof( buf ),
"unable to normalize value #%lu "
"of AttributeDescription %s",
k - oldcount,
at->bam_ad->ad_cname.bv_val );
Debug( LDAP_DEBUG_TRACE,
"==>backsql_get_attr_vals(\"%s\"): "
"%s (%d)\n",
bsi->bsi_e->e_name.bv_val, buf, retval );
#ifdef BACKSQL_PRETTY_VALIDATE
if ( pretty ) {
bsi->bsi_op->o_tmpfree( bv.bv_val,
bsi->bsi_op->o_tmpmemctx );
}
#endif /* BACKSQL_PRETTY_VALIDATE */
continue;
}
ber_dupbv( &attr->a_nvals[ j ], &nbv );
bsi->bsi_op->o_tmpfree( nbv.bv_val,
bsi->bsi_op->o_tmpmemctx );
}
ber_dupbv( &attr->a_vals[ j ], &bv );
assert( j < oldcount + count );
j++;
#endif /* BACKSQL_COUNTQUERY */
#ifdef BACKSQL_PRETTY_VALIDATE
if ( pretty ) {
bsi->bsi_op->o_tmpfree( bv.bv_val,
bsi->bsi_op->o_tmpmemctx );
}
#endif /* BACKSQL_PRETTY_VALIDATE */
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "prec=%d\n",
(int)row.col_prec[ i ], 0, 0 );
} else {
Debug( LDAP_DEBUG_TRACE, "NULL value "
"in this row for attribute \"%s\"\n",
row.col_names[ i ].bv_val, 0, 0 );
#endif /* BACKSQL_TRACE */
}
}
}
#ifdef BACKSQL_COUNTQUERY
if ( BER_BVISNULL( &attr->a_vals[ 0 ] ) ) {
/* don't leave around attributes with no values */
attr_free( attr );
} else if ( append ) {
Attribute **ap;
for ( ap = &bsi->bsi_e->e_attrs; (*ap) != NULL; ap = &(*ap)->a_next )
/* goto last */ ;
*ap = attr;
}
#endif /* BACKSQL_COUNTQUERY */
SQLFreeStmt( sth, SQL_DROP );
Debug( LDAP_DEBUG_TRACE, "<==backsql_get_attr_vals()\n", 0, 0, 0 );
if ( at->bam_next ) {
res = backsql_get_attr_vals( at->bam_next, v_bsi );
} else {
res = 1;
}
#ifdef BACKSQL_TRACE
done:;
#endif /* BACKSQL_TRACE */
backsql_FreeRow_x( &row, bsi->bsi_op->o_tmpmemctx );
return res;
}
RETCODE
backsql_Prepare( SQLHDBC dbh, SQLHSTMT *sth, char *query, int timeout )
{
RETCODE rc;
rc = SQLAllocStmt( dbh, sth );
if ( rc != SQL_SUCCESS ) {
return rc;
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "==>backsql_Prepare()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
#ifdef BACKSQL_MSSQL_WORKAROUND
{
char drv_name[ 30 ];
SWORD len;
SQLGetInfo( dbh, SQL_DRIVER_NAME, drv_name, sizeof( drv_name ), &len );
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "backsql_Prepare(): driver name=\"%s\"\n",
drv_name, 0, 0 );
#endif /* BACKSQL_TRACE */
ldap_pvt_str2upper( drv_name );
if ( !strncmp( drv_name, "SQLSRV32.DLL", STRLENOF( "SQLSRV32.DLL" ) ) ) {
/*
* stupid default result set in MS SQL Server
* does not support multiple active statements
* on the same connection -- so we are trying
* to make it not to use default result set...
*/
Debug( LDAP_DEBUG_TRACE, "_SQLprepare(): "
"enabling MS SQL Server default result "
"set workaround\n", 0, 0, 0 );
rc = SQLSetStmtOption( *sth, SQL_CONCURRENCY,
SQL_CONCUR_ROWVER );
if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO ) {
Debug( LDAP_DEBUG_TRACE, "backsql_Prepare(): "
"SQLSetStmtOption(SQL_CONCURRENCY,"
"SQL_CONCUR_ROWVER) failed:\n",
0, 0, 0 );
backsql_PrintErrors( SQL_NULL_HENV, dbh, *sth, rc );
SQLFreeStmt( *sth, SQL_DROP );
return rc;
}
}
}
#endif /* BACKSQL_MSSQL_WORKAROUND */
if ( timeout > 0 ) {
Debug( LDAP_DEBUG_TRACE, "_SQLprepare(): "
"setting query timeout to %d sec.\n",
timeout, 0, 0 );
rc = SQLSetStmtOption( *sth, SQL_QUERY_TIMEOUT, timeout );
if ( rc != SQL_SUCCESS ) {
backsql_PrintErrors( SQL_NULL_HENV, dbh, *sth, rc );
SQLFreeStmt( *sth, SQL_DROP );
return rc;
}
}
#ifdef BACKSQL_TRACE
Debug( LDAP_DEBUG_TRACE, "<==backsql_Prepare() calling SQLPrepare()\n",
0, 0, 0 );
#endif /* BACKSQL_TRACE */
return SQLPrepare( *sth, (SQLCHAR *)query, SQL_NTS );
}
/*
---------------------------------------------------------
TestSQLNumResultsCol
---------------------------------------------------------
*/
PassFail TestSQLNumResultCols(TestInfo *pTestInfo)
{
TEST_DECLARE;
TCHAR Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
SWORD col;
TCHAR *ExecDirStr[] = {_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--")};
TCHAR *TestCase[] = {
_T("after preparing stmt "),
_T("after preparing & executing stmt "),
_T("after preparing, executing & fetching stmt "),
_T("after execdirect stmt "),
_T("after execdirect & fetching stmt "),
_T("after preparing param stmt "),
_T("after preparing & binding stmt "),
_T("after preparing, binding & executing stmt "),
_T("after preparing, binding, executing & fetching stmt ")
};
int lend = 9, iend = 5;
SQLUSMALLINT i = 0, l = 0;
int expcol[] = {1,2,6,9,2};
SQLLEN cbIn = SQL_NTS;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLNumResultCols"), charset_file);
if (var_list == NULL) return FAILED;
ExecDirStr[0] = var_mapping(_T("SQLNumResultCols_ExecDirStr_0"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLNumResultCols_ExecDirStr_1"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLNumResultCols_ExecDirStr_2"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLNumResultCols_ExecDirStr_3"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLNumResultCols_ExecDirStr_4"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLNumResultCols_ExecDirStr_5"), var_list);
ExecDirStr[6] = var_mapping(_T("SQLNumResultCols_ExecDirStr_6"), var_list);
ExecDirStr[7] = var_mapping(_T("SQLNumResultCols_ExecDirStr_7"), var_list);
ExecDirStr[8] = var_mapping(_T("SQLNumResultCols_ExecDirStr_8"), var_list);
ExecDirStr[9] = var_mapping(_T("SQLNumResultCols_ExecDirStr_9"), var_list);
ExecDirStr[10] = var_mapping(_T("SQLNumResultCols_ExecDirStr_10"), var_list);
ExecDirStr[11] = var_mapping(_T("SQLNumResultCols_ExecDirStr_11"), var_list);
ExecDirStr[12] = var_mapping(_T("SQLNumResultCols_ExecDirStr_12"), var_list);
ExecDirStr[13] = var_mapping(_T("SQLNumResultCols_ExecDirStr_13"), var_list);
ExecDirStr[14] = var_mapping(_T("SQLNumResultCols_ExecDirStr_14"), var_list);
ExecDirStr[15] = var_mapping(_T("SQLNumResultCols_ExecDirStr_15"), var_list);
ExecDirStr[16] = var_mapping(_T("SQLNumResultCols_ExecDirStr_16"), var_list);
ExecDirStr[17] = var_mapping(_T("SQLNumResultCols_ExecDirStr_17"), var_list);
ExecDirStr[18] = var_mapping(_T("SQLNumResultCols_ExecDirStr_18"), var_list);
ExecDirStr[19] = var_mapping(_T("SQLNumResultCols_ExecDirStr_19"), var_list);
//===========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API =>SQLNumResultcols.\n"));
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLNumResultCols tests\n");
if(!FullConnect(pTestInfo)){
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END; // end of setup
for (l = 0; l < lend; l++){
for (i = 0; i < iend; i++){
//==================================================================================
_stprintf(Heading,_T("Test Positive Functionality of SQLNumResultCols "));
_tcscat(Heading, TestCase[l]);
_tcscat(Heading, ExecDirStr[i+iend+iend+iend]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
if ((i != (iend-1)) && (l < 5)){
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
switch( l ) {
case 0:
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 1 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 2 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
case 3 :
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 4 :
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
}
if (returncode == SQL_SUCCESS){
returncode = SQLNumResultCols(hstmt, &col);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
if (col == expcol[i])
{
LogMsg(NONE,_T("expect: %d and actual: %d are matched\n"),expcol[i], col);
}
else
{
TEST_FAILED;
LogMsg(NONE,_T("expect: %d and actual: %d are not matched\n"),expcol[i], col);
}
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */
}
}
}
else if ((i == (iend-1)) && (l >= 5)){
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
switch( l ){
case 5 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 6 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
case 7 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
}
break;
case 8 :
returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
}
}
break;
}
if (returncode == SQL_SUCCESS){
returncode = SQLNumResultCols(hstmt, &col);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
if (col == expcol[i])
{
LogMsg(NONE,_T("expect: %d and actual: %d are matched\n"),expcol[i], col);
}
else
{
TEST_FAILED;
LogMsg(NONE,_T("expect: %d and actual: %d are not matched\n"),expcol[i], col);
}
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */
}
}
}
TESTCASE_END;
} /* iend loop */
} /* lend loop */
FullDisconnect(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLNumResultcols.\n"));
free_list(var_list);
TEST_RETURN;
}
/*************************************************************************
* f_sql_exec( int handle, string statement )
*
* executes an SQL statement
*************************************************************************/
svalue_t *
f_sql_exec( svalue_t * argv, int argc )
{
#if ODBC_DEBUG & DEBUG_FUNC
printf( "call f_sql_exec( )\n" );
#endif
int id, i;
SQLCHAR * statement;
hDBC * handle;
//SQLSMALLINT cols;
SQLRETURN ret;
TYPE_TEST2( argv, T_STRING );
statement = string_copy( argv->u.string );
free_string_svalue( argv );
argv--;
TYPE_TEST1( argv, T_NUMBER );
id = argv->u.number;
free_svalue( argv );
if ( !(handle = get_db_connection_by_id( id )) ) {
pfree( statement );
errorf( "Illegal handle for database.\n" );
return( NULL );
}
if ( handle->hStmt ) {
//printf( "freeing statement\n" );
ret = SQLFreeStmt( handle->hStmt, SQL_UNBIND );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "SQLFreeStmt( handle->hStmt, SQL_UNBIND ) = %d\n", ret );
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
return( NULL );
}
ret = SQLFreeHandle( SQL_HANDLE_STMT, handle->hStmt );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "SQLFreeHandle( SQL_HANDLE_STMT, handle->hStmt ) = %d\n", ret );
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
return( NULL );
}
}
if ( handle->columns ) {
for ( i = 0; i < handle->colcnt; ++i ) {
dispose_column_meta_data( handle->columns[ i ] );
}
pfree( handle->columns );
handle->columns = NULL;
}
//printf( "allocating statement \n" );
ret = SQLAllocHandle( SQL_HANDLE_STMT, handle->hDBCon, &handle->hStmt );
if ( !SQL_SUCCEEDED( ret ) ) {
pfree( statement );
errorf( extract_diagnostics_info( SQL_HANDLE_DBC, handle->hDBCon ) );
return( NULL );
}
handle->colcnt = 0;
handle->rowcnt = 0;
// printf( "executing\n" );
ret = SQLExecDirect( handle->hStmt, statement, SQL_NTS );
pfree( statement );
if ( !SQL_SUCCEEDED( ret ) ) {
//printf( "XXX: %s\n", extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ) );
put_number( argv, 0 );
return( argv );
}
/* getting number of columns. */
//ret = SQLNumResultCols( handle->hStmt, &cols );
ret = SQLNumResultCols( handle->hStmt, &handle->colcnt );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
ret = SQLRowCount( handle->hStmt, &handle->rowcnt );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
//handle->colcnt = cols;
if ( handle->colcnt ) {
handle->columns = pxalloc( handle->colcnt * sizeof( COL_META_DATA* ) );
MEM_CHECK( handle->columns );
}
/* fetching meta data */
COL_META_DATA * tmp;
SQLCHAR dColname[ 100 ];
SQLSMALLINT dColnameLen;
SQLSMALLINT dType;
SQLSMALLINT dDDigits;
SQLSMALLINT dNullable;
SQLUINTEGER dColSize;
for ( i = 1; i <= handle->colcnt; ++i ) {
ret = SQLDescribeCol( handle->hStmt, i, dColname, sizeof( dColname ), &dColnameLen, &dType, &dColSize, &dDDigits, &dNullable );
if ( !SQL_SUCCEEDED( ret ) ) {
put_number( argv, 0 );
return( argv );
}
tmp = allocate_column_meta_data();
MEM_CHECK( tmp );
tmp->nr = i;
tmp->name = string_copy( dColname );
tmp->type = map_column_type( dType, dDDigits );
// printf( "[%s] dColSize=%d dDDigits=%d\n", dColname, dColSize, dDDigits );
SQLLEN len;
switch( tmp->type ) {
case T_NUMBER:
tmp->data.number_v = pxalloc( sizeof( SQL_C_LONG ) );
*tmp->data.number_v = 0;
SQLBindCol( handle->hStmt, i, SQL_C_LONG, tmp->data.number_v, 100, &len );
break;
case T_FLOAT:
tmp->data.double_v = pxalloc( sizeof( SQL_C_DOUBLE ) );
*tmp->data.double_v = 0;
SQLBindCol( handle->hStmt, i, SQL_C_DOUBLE, tmp->data.double_v, 100, &len );
break;
default:
tmp->data.string_v = pxalloc( (dColSize + 1) * sizeof( SQLCHAR ) );
SQLBindCol( handle->hStmt, i, SQL_C_CHAR, tmp->data.string_v, (dColSize + 1), &len );
}
handle->columns[ i-1 ] = tmp;
}
put_number( argv, id );
#if ODBC_DEBUG & DEBUG_FUNC
printf( "ret f_sql_exec( )\n" );
#endif
return( argv );
}
/****************************
* ExecuteHelp - create a statement, execute the SQL, and get rid of the statement
* - show results as per request; bHTMLTable has precedence over other options
***************************/
static int
ExecuteHelp( SQLHDBC hDbc, char *szSQL, char cDelimiter, int bColumnNames, int bHTMLTable )
{
SQLHSTMT hStmt;
SQLLEN nRows = 0;
SQLRETURN nReturn;
SQLCHAR *szSepLine;
char *args[10];
int n_args;
if (!(szSepLine = calloc(1, 32001)))
{
fprintf(stderr, "[ISQL]ERROR: Failed to allocate line");
return 0;
}
/****************************
* EXECUTE SQL
***************************/
if ( version3 )
{
if ( SQLAllocHandle( SQL_HANDLE_STMT, hDbc, &hStmt ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 );
fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocHandle( SQL_HANDLE_STMT )\n" );
free(szSepLine);
return 0;
}
}
else
{
if ( SQLAllocStmt( hDbc, &hStmt ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 );
fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocStmt\n" );
free(szSepLine);
return 0;
}
}
n_args = get_args(szSQL, &args[0], sizeof(args) / sizeof(args[0]));
if (n_args == 2 )
{
if (strcmp(args[1], "help") == 0)
{
output_help();
free(szSepLine);
return 0;
}
/* COLUMNS */
nReturn = SQLColumns( hStmt, NULL, 0, NULL, 0, (SQLCHAR*)args[1], SQL_NTS, NULL, 0 );
if ( (nReturn != SQL_SUCCESS) && (nReturn != SQL_SUCCESS_WITH_INFO) )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLColumns\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
return 0;
}
}
else
{
SQLCHAR *catalog = NULL;
SQLCHAR *schema = NULL;
SQLCHAR *table = NULL;
SQLCHAR *type = NULL;
if (n_args > 2)
{
catalog = (SQLCHAR*)args[1];
schema = (SQLCHAR*)args[2];
table = (SQLCHAR*)args[3];
type = (SQLCHAR*)args[4];
}
/* TABLES */
nReturn = SQLTables( hStmt, catalog, SQL_NTS, schema, SQL_NTS,
table, SQL_NTS, type, SQL_NTS );
if ( (nReturn != SQL_SUCCESS) && (nReturn != SQL_SUCCESS_WITH_INFO) )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLTables\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
free_args(args, sizeof(args) / sizeof(args[0]));
return 0;
}
}
/****************************
* WRITE HEADER
***************************/
if ( bHTMLTable )
WriteHeaderHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteHeaderNormal( hStmt, szSepLine );
else if ( cDelimiter && bColumnNames )
WriteHeaderDelimited( hStmt, cDelimiter );
/****************************
* WRITE BODY
***************************/
if ( bHTMLTable )
WriteBodyHTMLTable( hStmt );
else if ( cDelimiter == 0 )
nRows = WriteBodyNormal( hStmt );
else
WriteBodyDelimited( hStmt, cDelimiter );
/****************************
* WRITE FOOTER
***************************/
if ( bHTMLTable )
WriteFooterHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteFooterNormal( hStmt, szSepLine, nRows );
/****************************
* CLEANUP
***************************/
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
free_args(args, sizeof(args) / sizeof(args[0]));
return 1;
}
/*
---------------------------------------------------------
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;
}
static void display_result_set( SQLHDBC hDbc, SQLHSTMT hStmt )
{
SQLCHAR *szSepLine;
SQLRETURN ret;
int mr;
SQLSMALLINT cols;
SQLLEN nRows = 0;
szSepLine = calloc(1, 32001);
/*
* Loop while SQLMoreResults returns success
*/
mr = 0;
do
{
if ( mr )
{
if ( ret == SQL_SUCCESS_WITH_INFO )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]INFO: SQLMoreResults returned SQL_SUCCESS_WITH_INFO\n" );
}
}
mr = 1;
strcpy ((char*) szSepLine, "" ) ;
/*
* check to see if it has generated a result set
*/
if ( SQLNumResultCols( hStmt, &cols ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLNumResultCols\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
}
if ( cols > 0 )
{
/****************************
* WRITE HEADER
***************************/
if ( bHTMLTable )
WriteHeaderHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteHeaderNormal( hStmt, szSepLine );
else if ( cDelimiter && bColumnNames )
WriteHeaderDelimited( hStmt, cDelimiter );
/****************************
* WRITE BODY
***************************/
if ( bHTMLTable )
WriteBodyHTMLTable( hStmt );
else if ( cDelimiter == 0 )
nRows = WriteBodyNormal( hStmt );
else
WriteBodyDelimited( hStmt, cDelimiter );
}
/****************************
* WRITE FOOTER
***************************/
if ( bHTMLTable )
WriteFooterHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteFooterNormal( hStmt, szSepLine, nRows );
}
while ( has_moreresults && SQL_SUCCEEDED( ret = SQLMoreResults( hStmt )));
free( szSepLine );
}
static void
AllTests(void)
{
struct tm *ltime;
char buf[80];
time_t curr_time;
SQLINTEGER y, m, d;
char date[128];
printf("use_cursors %d exec_direct %d prepare_before %d\n", use_cursors, exec_direct, prepare_before);
/* test some NULLs */
NullInput(SQL_C_CHAR, SQL_VARCHAR, "VARCHAR(100)");
NullInput(SQL_C_CHAR, SQL_LONGVARCHAR, "TEXT");
NullInput(SQL_C_LONG, SQL_INTEGER, "INTEGER");
NullInput(SQL_C_LONG, SQL_LONGVARCHAR, "TEXT");
NullInput(SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, "DATETIME");
NullInput(SQL_C_FLOAT, SQL_REAL, "FLOAT");
NullInput(SQL_C_NUMERIC, SQL_LONGVARCHAR, "TEXT");
if (odbc_db_is_microsoft() && odbc_db_version_int() >= 0x08000000u)
NullInput(SQL_C_BIT, SQL_BIT, "BIT");
NullInput(SQL_C_DOUBLE, SQL_DOUBLE, "MONEY");
/* FIXME why should return 38 0 as precision and scale ?? correct ?? */
precision = 18;
TestOutput("NUMERIC(18,2)", "123", SQL_C_NUMERIC, SQL_NUMERIC, "18 0 1 7B");
TestOutput("DECIMAL(18,2)", "123", SQL_C_NUMERIC, SQL_DECIMAL, "18 0 1 7B");
precision = 38;
TestOutput("NUMERIC(18,2)", "123", SQL_C_NUMERIC, SQL_NUMERIC, "38 0 1 7B");
TestInput(SQL_C_LONG, "INTEGER", SQL_VARCHAR, "VARCHAR(20)", "12345");
TestInput(SQL_C_LONG, "INTEGER", SQL_LONGVARCHAR, "TEXT", "12345");
/*
* MS driver behavior for output parameters is different
* former returns "313233" while newer "333133323333"
*/
if (odbc_driver_is_freetds())
TestOutput("VARCHAR(20)", "313233", SQL_C_BINARY, SQL_VARCHAR, "333133323333");
only_test = 1;
precision = 3;
if (TestOutput("DATETIME", "2004-02-24 15:16:17", SQL_C_BINARY, SQL_TIMESTAMP, pack("ssssssl", 2004, 2, 24, 15, 16, 17, 0))) {
/* FIXME our driver ignore precision for date */
precision = 3;
/* Some MS driver incorrectly prepare with smalldatetime*/
if (!use_cursors || odbc_driver_is_freetds()) {
TestOutput("DATETIME", "2004-02-24 15:16:17", SQL_C_BINARY, SQL_TIMESTAMP, pack("ll", 0x9497, 0xFBAA2C));
}
TestOutput("SMALLDATETIME", "2004-02-24 15:16:17", SQL_C_BINARY, SQL_TIMESTAMP, pack("ll", 0x9497, 0xFB9640));
} else {
TestOutput("SMALLDATETIME", "2004-02-24 15:16:17", SQL_C_BINARY, SQL_TIMESTAMP, pack("ssssssl", 2004, 2, 24, 15, 16, 0, 0));
}
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34");
/* test timestamp millisecond round off */
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.001 -> 2005-07-22 09:51:34.000");
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.002 -> 2005-07-22 09:51:34.003");
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.003 -> 2005-07-22 09:51:34.003");
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.004 -> 2005-07-22 09:51:34.003");
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.005 -> 2005-07-22 09:51:34.007");
TestInput(SQL_C_TYPE_TIMESTAMP, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 09:51:34.006 -> 2005-07-22 09:51:34.007");
/* FIXME on ms driver first SQLFetch return SUCCESS_WITH_INFO for truncation error */
TestInput(SQL_C_TYPE_DATE, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", "2005-07-22 13:02:03 -> 2005-07-22 00:00:00");
/* replace date information with current date */
time(&curr_time);
ltime = localtime(&curr_time);
y = ltime->tm_year + 1900;
m = ltime->tm_mon + 1;
d = ltime->tm_mday;
/* server concept of data can be different so try ask to server */
odbc_command("SELECT GETDATE()");
SQLBindCol(odbc_stmt, 1, SQL_C_CHAR, date, sizeof(date), NULL);
if (SQLFetch(odbc_stmt) == SQL_SUCCESS) {
int a, b, c;
if (sscanf(date, "%d-%d-%d", &a, &b, &c) == 3) {
y = a;
m = b;
d = c;
}
}
SQLFetch(odbc_stmt);
SQLMoreResults(odbc_stmt);
SQLFreeStmt(odbc_stmt, SQL_UNBIND);
sprintf(buf, "2003-07-22 13:02:03 -> %04d-%02d-%02d 13:02:03", (int) y, (int) m, (int) d);
TestInput(SQL_C_TYPE_TIME, "DATETIME", SQL_TYPE_TIMESTAMP, "DATETIME", buf);
TestInput(SQL_C_FLOAT, "FLOAT", SQL_REAL, "FLOAT", "1234.25");
TestInput(SQL_C_DOUBLE, "REAL", SQL_REAL, "FLOAT", "-1234.25");
TestInput(SQL_C_FLOAT, "REAL", SQL_REAL, "FLOAT", "1234.25");
TestInput(SQL_C_DOUBLE, "FLOAT", SQL_REAL, "FLOAT", "-1234.25");
TestInput(SQL_C_FLOAT, "FLOAT", SQL_FLOAT, "FLOAT", "1234.25");
TestInput(SQL_C_DOUBLE, "REAL", SQL_FLOAT, "FLOAT", "-1234.25");
TestInput(SQL_C_FLOAT, "FLOAT", SQL_DOUBLE, "FLOAT", "1234.25");
TestInput(SQL_C_DOUBLE, "REAL", SQL_DOUBLE, "FLOAT", "-1234.25");
TestInput(SQL_C_UTINYINT, "TINYINT", SQL_TINYINT, "TINYINT", "231");
TestInput(SQL_C_NUMERIC, "NUMERIC(20,3)", SQL_NUMERIC, "NUMERIC(20,3)", "765432.2 -> 765432");
TestInput(SQL_C_NUMERIC, "NUMERIC(20,3)", SQL_VARCHAR, "VARCHAR(20)", "578246.234 -> 578246");
TestInput(SQL_C_NUMERIC, "NUMERIC(20,3)", SQL_LONGVARCHAR, "TEXT", "578246.234 -> 578246");
TestInput(SQL_C_CHAR, "VARCHAR(100)", SQL_VARBINARY, "VARBINARY(20)", "4145544F -> AETO");
TestInput(SQL_C_CHAR, "TEXT", SQL_VARBINARY, "VARBINARY(20)", "4145544F -> AETO");
TestInput(SQL_C_CHAR, "VARCHAR(100)", SQL_LONGVARBINARY, "IMAGE", "4145544F -> AETO");
TestInput(SQL_C_BINARY, "VARBINARY(100)", SQL_VARCHAR, "VARCHAR(20)", "0x4145544F -> AETO");
TestInput(SQL_C_BINARY, "IMAGE", SQL_VARCHAR, "VARCHAR(20)", "0x4145544F -> AETO");
TestInput(SQL_C_BIT, "BIT", SQL_BIT, "BIT", "0");
TestInput(SQL_C_BIT, "BIT", SQL_BIT, "BIT", "1");
TestInput(SQL_C_DOUBLE, "MONEY", SQL_DOUBLE, "MONEY", "123.34");
TestInput(SQL_C_CHAR, "VARCHAR(20)", SQL_VARCHAR, "VARCHAR(20)", "1EasyTest");
TestInput(SQL_C_CHAR, "VARCHAR(20)", SQL_LONGVARCHAR, "TEXT", "1EasyTest");
TestInput(SQL_C_WCHAR, "VARCHAR(10)", SQL_VARCHAR, "VARCHAR(10)", "Test 12345");
TestInput(SQL_C_WCHAR, "VARCHAR(10)", SQL_LONGVARCHAR, "TEXT", "Test 12345");
/* TODO use collate in syntax if available */
TestInput(SQL_C_CHAR, "VARCHAR(20)", SQL_VARCHAR, "VARCHAR(20)", "me\xf4");
TestInput(SQL_C_CHAR, "VARCHAR(20)", SQL_LONGVARCHAR, "TEXT", "me\xf4");
precision = 6;
/* output from char with conversions */
TestOutput("VARCHAR(20)", "foo test", SQL_C_CHAR, SQL_VARCHAR, "6 foo te");
/* TODO use collate in sintax if available */
TestOutput("VARCHAR(20)", "0xf8f9", SQL_C_CHAR, SQL_VARCHAR, "2 \xf8\xf9");
if ((odbc_db_is_microsoft() && odbc_db_version_int() >= 0x08000000u && odbc_tds_version() > 0x700)
|| (!odbc_db_is_microsoft() && strncmp(odbc_db_version(), "15.00.", 6) >= 0)) {
TestOutput("BIGINT", "-987654321065432", SQL_C_BINARY, SQL_BIGINT, big_endian ? "FFFC7DBBCF083228" : "283208CFBB7DFCFF");
TestInput(SQL_C_SBIGINT, "BIGINT", SQL_BIGINT, "BIGINT", "-12345678901234");
}
if (odbc_db_is_microsoft() && odbc_db_version_int() >= 0x08000000u) {
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WCHAR, "NVARCHAR(100)", "test");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WLONGVARCHAR, "NTEXT", "test");
/* test for invalid stream due to truncation*/
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WCHAR, "NVARCHAR(100)", "01234567890");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WLONGVARCHAR, "NTEXT", "01234567890");
#ifdef ENABLE_DEVELOPING
check_truncation = 1;
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WCHAR, "NVARCHAR(100)", "012345678901234567890");
check_truncation = 1;
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WLONGVARCHAR, "NTEXT", "012345678901234567890");
#endif
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WCHAR, "NVARCHAR(100)", "\xa3h\xf9 -> 0xA3006800f900");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WLONGVARCHAR, "NTEXT", "\xa3h\xf9 -> 0xA3006800f900");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WCHAR, "NVARCHAR(100)", "0xA3006800f900 -> \xa3h\xf9");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_WLONGVARCHAR, "NTEXT", "0xA3006800f900 -> \xa3h\xf9");
TestInput(SQL_C_LONG, "INT", SQL_WVARCHAR, "NVARCHAR(100)", "45236");
TestInput(SQL_C_LONG, "INT", SQL_WLONGVARCHAR, "NTEXT", "45236");
precision = 6;
TestOutput("NVARCHAR(20)", "foo test", SQL_C_CHAR, SQL_WVARCHAR, "6 foo te");
precision = 12;
TestOutput("NVARCHAR(20)", "foo test", SQL_C_CHAR, SQL_WVARCHAR, "8 foo test");
/* TODO use collate in sintax if available */
TestOutput("NVARCHAR(20)", "0xf800f900", SQL_C_CHAR, SQL_WVARCHAR, "2 \xf8\xf9");
TestInput(SQL_C_WCHAR, "NVARCHAR(10)", SQL_WVARCHAR, "NVARCHAR(10)", "1EasyTest2");
TestInput(SQL_C_WCHAR, "NVARCHAR(10)", SQL_WLONGVARCHAR, "NTEXT", "1EasyTest2");
use_nts = 1;
TestInput(SQL_C_WCHAR, "NVARCHAR(10)", SQL_WVARCHAR, "NVARCHAR(10)", "1EasyTest3");
use_nts = 1;
TestInput(SQL_C_WCHAR, "NVARCHAR(10)", SQL_WLONGVARCHAR, "NTEXT", "1EasyTest3");
TestInput(SQL_C_WCHAR, "NVARCHAR(3)", SQL_WVARCHAR, "NVARCHAR(3)", "0xf800a300bc06");
TestInput(SQL_C_WCHAR, "NVARCHAR(3)", SQL_WLONGVARCHAR, "NTEXT", "0xf800a300bc06");
TestInput(SQL_C_WCHAR, "NVARCHAR(10)", SQL_INTEGER, "INT", " -423785 -> -423785");
TestInput(SQL_C_CHAR, "NVARCHAR(100)", SQL_VARBINARY, "VARBINARY(20)", "4145544F -> AETO");
TestInput(SQL_C_CHAR, "NTEXT", SQL_VARBINARY, "VARBINARY(20)", "4145544F -> AETO");
TestInput(SQL_C_BINARY, "VARBINARY(100)", SQL_WVARCHAR, "NVARCHAR(20)", "0x4100450054004F00 -> AETO");
TestInput(SQL_C_BINARY, "IMAGE", SQL_WVARCHAR, "NVARCHAR(20)", "0x4100450054004F00 -> AETO");
}
if (odbc_db_is_microsoft() && odbc_db_version_int() >= 0x09000000u) {
TestInput(SQL_C_CHAR, "VARCHAR(20)", SQL_LONGVARCHAR, "VARCHAR(MAX)", "1EasyTest");
TestInput(SQL_C_BINARY, "VARBINARY(20)", SQL_LONGVARBINARY, "VARBINARY(MAX)", "Anything will suite!");
}
}
/****************************
* ExecuteSQL - create a statement, execute the SQL, and get rid of the statement
* - show results as per request; bHTMLTable has precedence over other options
***************************/
static int
ExecuteSQL( SQLHDBC hDbc, char *szSQL, char cDelimiter, int bColumnNames, int bHTMLTable )
{
SQLHSTMT hStmt;
SQLSMALLINT cols;
SQLLEN nRows = 0;
SQLINTEGER ret;
SQLCHAR *szSepLine;
int mr;
szSepLine = calloc(1, 32001);
/****************************
* EXECUTE SQL
***************************/
if ( version3 )
{
if ( SQLAllocHandle( SQL_HANDLE_STMT, hDbc, &hStmt ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 );
fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocHandle( SQL_HANDLE_STMT )\n" );
free(szSepLine);
return 0;
}
}
else
{
if ( SQLAllocStmt( hDbc, &hStmt ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 );
fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocStmt\n" );
free(szSepLine);
return 0;
}
}
if ( SQLPrepare( hStmt, (SQLCHAR*)szSQL, strlen( szSQL )) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLPrepare\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
return 0;
}
ret = SQLExecute( hStmt );
if ( ret == SQL_NO_DATA )
{
fprintf( stderr, "[ISQL]INFO: SQLExecute returned SQL_NO_DATA\n" );
}
else if ( ret == SQL_SUCCESS_WITH_INFO )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]INFO: SQLExecute returned SQL_SUCCESS_WITH_INFO\n" );
}
else if ( ret != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLExecute\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
return 0;
}
/*
* Loop while SQLMoreResults returns success
*/
mr = 0;
do
{
if ( mr )
{
if ( ret == SQL_SUCCESS_WITH_INFO )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]INFO: SQLMoreResults returned SQL_SUCCESS_WITH_INFO\n" );
}
}
mr = 1;
strcpy ((char*) szSepLine, "" ) ;
/*
* check to see if it has generated a result set
*/
if ( SQLNumResultCols( hStmt, &cols ) != SQL_SUCCESS )
{
if ( bVerbose ) DumpODBCLog( hEnv, hDbc, hStmt );
fprintf( stderr, "[ISQL]ERROR: Could not SQLNumResultCols\n" );
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
return 0;
}
if ( cols > 0 )
{
/****************************
* WRITE HEADER
***************************/
if ( bHTMLTable )
WriteHeaderHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteHeaderNormal( hStmt, szSepLine );
else if ( cDelimiter && bColumnNames )
WriteHeaderDelimited( hStmt, cDelimiter );
/****************************
* WRITE BODY
***************************/
if ( bHTMLTable )
WriteBodyHTMLTable( hStmt );
else if ( cDelimiter == 0 )
nRows = WriteBodyNormal( hStmt );
else
WriteBodyDelimited( hStmt, cDelimiter );
}
/****************************
* WRITE FOOTER
***************************/
if ( bHTMLTable )
WriteFooterHTMLTable( hStmt );
else if ( cDelimiter == 0 )
WriteFooterNormal( hStmt, szSepLine, nRows );
}
while ( has_moreresults && SQL_SUCCEEDED( ret = SQLMoreResults( hStmt )));
/****************************
* CLEANUP
***************************/
SQLFreeStmt( hStmt, SQL_DROP );
free(szSepLine);
return 1;
}
int
backsql_modrdn( Operation *op, SlapReply *rs )
{
backsql_info *bi = (backsql_info*)op->o_bd->be_private;
SQLHDBC dbh = SQL_NULL_HDBC;
SQLHSTMT sth = SQL_NULL_HSTMT;
RETCODE rc;
backsql_entryID e_id = BACKSQL_ENTRYID_INIT,
n_id = BACKSQL_ENTRYID_INIT;
backsql_srch_info bsi = { 0 };
backsql_oc_map_rec *oc = NULL;
struct berval pdn = BER_BVNULL, pndn = BER_BVNULL,
*new_pdn = NULL, *new_npdn = NULL,
new_dn = BER_BVNULL, new_ndn = BER_BVNULL,
realnew_dn = BER_BVNULL;
Entry r = { 0 },
p = { 0 },
n = { 0 },
*e = NULL;
int manageDSAit = get_manageDSAit( op );
struct berval *newSuperior = op->oq_modrdn.rs_newSup;
Debug( LDAP_DEBUG_TRACE, "==>backsql_modrdn() renaming entry \"%s\", "
"newrdn=\"%s\", newSuperior=\"%s\"\n",
op->o_req_dn.bv_val, op->oq_modrdn.rs_newrdn.bv_val,
newSuperior ? newSuperior->bv_val : "(NULL)" );
rs->sr_err = backsql_get_db_conn( op, &dbh );
if ( rs->sr_err != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"could not get connection handle - exiting\n" );
rs->sr_text = ( rs->sr_err == LDAP_OTHER )
? "SQL-backend error" : NULL;
e = NULL;
goto done;
}
bsi.bsi_e = &r;
rs->sr_err = backsql_init_search( &bsi, &op->o_req_ndn,
LDAP_SCOPE_BASE,
(time_t)(-1), NULL, dbh, op, rs,
slap_anlist_all_attributes,
( BACKSQL_ISF_MATCHED | BACKSQL_ISF_GET_ENTRY | BACKSQL_ISF_GET_OC ) );
switch ( rs->sr_err ) {
case LDAP_SUCCESS:
break;
case LDAP_REFERRAL:
if ( manageDSAit && !BER_BVISNULL( &bsi.bsi_e->e_nname ) &&
dn_match( &op->o_req_ndn, &bsi.bsi_e->e_nname ) )
{
rs->sr_err = LDAP_SUCCESS;
rs->sr_text = NULL;
rs->sr_matched = NULL;
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
}
break;
}
e = &r;
/* fallthru */
default:
Debug( LDAP_DEBUG_TRACE, "backsql_modrdn(): "
"could not retrieve modrdnDN ID - no such entry\n" );
if ( !BER_BVISNULL( &r.e_nname ) ) {
/* FIXME: should always be true! */
e = &r;
} else {
e = NULL;
}
goto done;
}
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): entry id=" BACKSQL_IDFMT "\n",
BACKSQL_IDARG(e_id.eid_id) );
if ( get_assert( op ) &&
( test_filter( op, &r, get_assertion( op ) )
!= LDAP_COMPARE_TRUE ) )
{
rs->sr_err = LDAP_ASSERTION_FAILED;
e = &r;
goto done;
}
if ( backsql_has_children( op, dbh, &op->o_req_ndn ) == LDAP_COMPARE_TRUE ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"entry \"%s\" has children\n",
op->o_req_dn.bv_val );
rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
rs->sr_text = "subtree rename not supported";
e = &r;
goto done;
}
/*
* Check for entry access to target
*/
if ( !access_allowed( op, &r, slap_schema.si_ad_entry,
NULL, ACL_WRITE, NULL ) ) {
Debug( LDAP_DEBUG_TRACE, " no access to entry\n" );
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
goto done;
}
dnParent( &op->o_req_dn, &pdn );
dnParent( &op->o_req_ndn, &pndn );
/*
* namingContext "" is not supported
*/
if ( BER_BVISEMPTY( &pdn ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"parent is \"\" - aborting\n" );
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
rs->sr_text = "not allowed within namingContext";
e = NULL;
goto done;
}
/*
* Check for children access to parent
*/
bsi.bsi_e = &p;
e_id = bsi.bsi_base_id;
memset( &bsi.bsi_base_id, 0, sizeof( bsi.bsi_base_id ) );
rs->sr_err = backsql_init_search( &bsi, &pndn,
LDAP_SCOPE_BASE,
(time_t)(-1), NULL, dbh, op, rs,
slap_anlist_all_attributes,
BACKSQL_ISF_GET_ENTRY );
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): old parent entry id is " BACKSQL_IDFMT "\n",
BACKSQL_IDARG(bsi.bsi_base_id.eid_id) );
if ( rs->sr_err != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_modrdn(): "
"could not retrieve renameDN ID - no such entry\n" );
e = &p;
goto done;
}
if ( !access_allowed( op, &p, slap_schema.si_ad_children, NULL,
newSuperior ? ACL_WDEL : ACL_WRITE, NULL ) )
{
Debug( LDAP_DEBUG_TRACE, " no access to parent\n" );
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
goto done;
}
if ( newSuperior ) {
(void)backsql_free_entryID( &bsi.bsi_base_id, 0, op->o_tmpmemctx );
/*
* namingContext "" is not supported
*/
if ( BER_BVISEMPTY( newSuperior ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"newSuperior is \"\" - aborting\n" );
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
rs->sr_text = "not allowed within namingContext";
e = NULL;
goto done;
}
new_pdn = newSuperior;
new_npdn = op->oq_modrdn.rs_nnewSup;
/*
* Check for children access to new parent
*/
bsi.bsi_e = &n;
rs->sr_err = backsql_init_search( &bsi, new_npdn,
LDAP_SCOPE_BASE,
(time_t)(-1), NULL, dbh, op, rs,
slap_anlist_all_attributes,
( BACKSQL_ISF_MATCHED | BACKSQL_ISF_GET_ENTRY ) );
if ( rs->sr_err != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_modrdn(): "
"could not retrieve renameDN ID - no such entry\n" );
e = &n;
goto done;
}
n_id = bsi.bsi_base_id;
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): new parent entry id=" BACKSQL_IDFMT "\n",
BACKSQL_IDARG(n_id.eid_id) );
if ( !access_allowed( op, &n, slap_schema.si_ad_children,
NULL, ACL_WADD, NULL ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"no access to new parent \"%s\"\n",
new_pdn->bv_val );
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
e = &n;
goto done;
}
} else {
n_id = bsi.bsi_base_id;
new_pdn = &pdn;
new_npdn = &pndn;
}
memset( &bsi.bsi_base_id, 0, sizeof( bsi.bsi_base_id ) );
if ( newSuperior && dn_match( &pndn, new_npdn ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"newSuperior is equal to old parent - ignored\n" );
newSuperior = NULL;
}
if ( newSuperior && dn_match( &op->o_req_ndn, new_npdn ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"newSuperior is equal to entry being moved "
"- aborting\n" );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "newSuperior is equal to old DN";
e = &r;
goto done;
}
build_new_dn( &new_dn, new_pdn, &op->oq_modrdn.rs_newrdn,
op->o_tmpmemctx );
build_new_dn( &new_ndn, new_npdn, &op->oq_modrdn.rs_nnewrdn,
op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): new entry dn is \"%s\"\n",
new_dn.bv_val );
realnew_dn = new_dn;
if ( backsql_api_dn2odbc( op, rs, &realnew_dn ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(\"%s\"): "
"backsql_api_dn2odbc(\"%s\") failed\n",
op->o_req_dn.bv_val, realnew_dn.bv_val );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"executing renentry_stmt\n" );
rc = backsql_Prepare( dbh, &sth, bi->sql_renentry_stmt, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): "
"error preparing renentry_stmt\n" );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, &realnew_dn );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): "
"error binding DN parameter for objectClass %s\n",
oc->bom_oc->soc_cname.bv_val );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
rc = backsql_BindParamID( sth, 2, SQL_PARAM_INPUT, &n_id.eid_id );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): "
"error binding parent ID parameter for objectClass %s\n",
oc->bom_oc->soc_cname.bv_val );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
rc = backsql_BindParamID( sth, 3, SQL_PARAM_INPUT, &e_id.eid_keyval );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): "
"error binding entry ID parameter for objectClass %s\n",
oc->bom_oc->soc_cname.bv_val );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
rc = backsql_BindParamID( sth, 4, SQL_PARAM_INPUT, &e_id.eid_id );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_modrdn(): "
"error binding ID parameter for objectClass %s\n",
oc->bom_oc->soc_cname.bv_val );
backsql_PrintErrors( bi->sql_db_env, dbh,
sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_text = "SQL-backend error";
rs->sr_err = LDAP_OTHER;
e = NULL;
goto done;
}
rc = SQLExecute( sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(): "
"could not rename ldap_entries record\n" );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
SQLFreeStmt( sth, SQL_DROP );
rs->sr_err = LDAP_OTHER;
rs->sr_text = "SQL-backend error";
e = NULL;
goto done;
}
SQLFreeStmt( sth, SQL_DROP );
assert( op->orr_modlist != NULL );
slap_mods_opattrs( op, &op->orr_modlist, 1 );
assert( e_id.eid_oc != NULL );
oc = e_id.eid_oc;
rs->sr_err = backsql_modify_internal( op, rs, dbh, oc, &e_id, op->orr_modlist );
slap_graduate_commit_csn( op );
if ( rs->sr_err != LDAP_SUCCESS ) {
e = &r;
goto done;
}
if ( BACKSQL_CHECK_SCHEMA( bi ) ) {
char textbuf[ SLAP_TEXT_BUFLEN ] = { '\0' };
backsql_entry_clean( op, &r );
(void)backsql_free_entryID( &e_id, 0, op->o_tmpmemctx );
bsi.bsi_e = &r;
rs->sr_err = backsql_init_search( &bsi, &new_ndn,
LDAP_SCOPE_BASE,
(time_t)(-1), NULL, dbh, op, rs,
slap_anlist_all_attributes,
( BACKSQL_ISF_MATCHED | BACKSQL_ISF_GET_ENTRY ) );
switch ( rs->sr_err ) {
case LDAP_SUCCESS:
break;
case LDAP_REFERRAL:
if ( manageDSAit && !BER_BVISNULL( &bsi.bsi_e->e_nname ) &&
dn_match( &new_ndn, &bsi.bsi_e->e_nname ) )
{
rs->sr_err = LDAP_SUCCESS;
rs->sr_text = NULL;
rs->sr_matched = NULL;
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
}
break;
}
e = &r;
/* fallthru */
default:
Debug( LDAP_DEBUG_TRACE, "backsql_modrdn(): "
"could not retrieve modrdnDN ID - no such entry\n" );
if ( !BER_BVISNULL( &r.e_nname ) ) {
/* FIXME: should always be true! */
e = &r;
} else {
e = NULL;
}
goto done;
}
e_id = bsi.bsi_base_id;
rs->sr_err = entry_schema_check( op, &r, NULL, 0, 0, NULL,
&rs->sr_text, textbuf, sizeof( textbuf ) );
if ( rs->sr_err != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, " backsql_modrdn(\"%s\"): "
"entry failed schema check -- aborting\n",
r.e_name.bv_val );
e = NULL;
goto done;
}
}
done:;
if ( e != NULL ) {
if ( !access_allowed( op, e, slap_schema.si_ad_entry, NULL,
ACL_DISCLOSE, NULL ) )
{
rs->sr_err = LDAP_NO_SUCH_OBJECT;
rs->sr_text = NULL;
rs->sr_matched = NULL;
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
}
}
}
/*
* Commit only if all operations succeed
*/
if ( sth != SQL_NULL_HSTMT ) {
SQLUSMALLINT CompletionType = SQL_ROLLBACK;
if ( rs->sr_err == LDAP_SUCCESS && !op->o_noop ) {
CompletionType = SQL_COMMIT;
}
SQLTransact( SQL_NULL_HENV, dbh, CompletionType );
}
if ( op->o_noop && rs->sr_err == LDAP_SUCCESS ) {
rs->sr_err = LDAP_X_NO_OPERATION;
}
send_ldap_result( op, rs );
slap_graduate_commit_csn( op );
if ( !BER_BVISNULL( &realnew_dn ) && realnew_dn.bv_val != new_dn.bv_val ) {
ch_free( realnew_dn.bv_val );
}
if ( !BER_BVISNULL( &new_dn ) ) {
slap_sl_free( new_dn.bv_val, op->o_tmpmemctx );
}
if ( !BER_BVISNULL( &new_ndn ) ) {
slap_sl_free( new_ndn.bv_val, op->o_tmpmemctx );
}
if ( !BER_BVISNULL( &e_id.eid_ndn ) ) {
(void)backsql_free_entryID( &e_id, 0, op->o_tmpmemctx );
}
if ( !BER_BVISNULL( &n_id.eid_ndn ) ) {
(void)backsql_free_entryID( &n_id, 0, op->o_tmpmemctx );
}
if ( !BER_BVISNULL( &r.e_nname ) ) {
backsql_entry_clean( op, &r );
}
if ( !BER_BVISNULL( &p.e_nname ) ) {
backsql_entry_clean( op, &p );
}
if ( !BER_BVISNULL( &n.e_nname ) ) {
backsql_entry_clean( op, &n );
}
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
}
Debug( LDAP_DEBUG_TRACE, "<==backsql_modrdn()\n" );
return rs->sr_err;
}
static void
testLargeResult(HSTMT hstmt, int betweenstmts)
{
int rc;
int i;
/*
* Fetch a large result set without cursor (in Declare/fetch mode, it will
* be fetched in chunks)
*/
rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT 'foo' || g FROM generate_series(1, 3210) g", SQL_NTS);
CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt);
/* Fetch the first 10 rows */
for (i = 0; i < 10; i++)
{
char buf[40];
SQLLEN ind;
rc = SQLFetch(hstmt);
if (rc != SQL_SUCCESS)
{
CHECK_STMT_RESULT(rc, "SQLFetch failed", hstmt);
}
rc = SQLGetData(hstmt, 1, SQL_C_CHAR, buf, sizeof(buf), &ind);
CHECK_STMT_RESULT(rc, "SQLGetData failed", hstmt);
printf("%s ", buf);
}
/* Now Commit, Rollback or do nothing depending on the argument */
switch (betweenstmts)
{
case 1:
printf("\nCommit\n");
rc = SQLEndTran(SQL_HANDLE_DBC, conn, SQL_COMMIT);
CHECK_STMT_RESULT(rc, "SQLEndTran failed\n", hstmt);
break;
case 2:
printf("\nRollback\n");
rc = SQLEndTran(SQL_HANDLE_DBC, conn, SQL_ROLLBACK);
CHECK_STMT_RESULT(rc, "SQLEndTran failed\n", hstmt);
break;
default:
/* do nothing */
break;
}
/*
* Try to fetch the rest of the result set.
* (Will fail in SQL_CB_CLOSE mode and succeed in SQL_CB_PRESERVE).
*/
for (;; i++)
{
char buf[40];
SQLLEN ind;
rc = SQLFetch(hstmt);
if (rc == SQL_NO_DATA)
break;
if (rc != SQL_SUCCESS)
{
char sqlstate[32] = "";
SQLINTEGER nativeerror;
SQLSMALLINT textlen;
SQLGetDiagRec(SQL_HANDLE_STMT, hstmt, 1, sqlstate, &nativeerror,
NULL, 0, &textlen);
if (strcmp(sqlstate, "HY010") == 0)
{
/* This is expected in SQL_CB_CLOSE mode */
printf("SQLFetch failed with HY010 (which probably means that the cursor was closed at commit/rollback)");
break;
}
else
CHECK_STMT_RESULT(rc, "SQLGetDiagRec failed", hstmt);
}
rc = SQLGetData(hstmt, 1, SQL_C_CHAR, buf, sizeof(buf), &ind);
CHECK_STMT_RESULT(rc, "SQLGetData failed", hstmt);
if (i == 20)
printf("... ");
else if (20 < i && i <= 3205)
{
/* skip printing, to keep the output short */
}
else
printf("%s ", buf);
}
printf("\nFetched %d rows altogether\n\n", i);
rc = SQLFreeStmt(hstmt, SQL_CLOSE);
CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt);
}
SQLRETURN unixodbc_backend::do_free_statement(SQLHSTMT statement_handle, SQLUSMALLINT option) const
{
return SQLFreeStmt(statement_handle, option);
}
CSqlRecordsetPtr CMssqlConnection::_Execute(const char *string)
{
cvs::string str = string;
SQLRETURN ret;
CMssqlRecordset *rs = new CMssqlRecordset();
CServerIo::trace(3,"%s",str.c_str());
bool inquote = false;
for(size_t n=0; n<str.size(); n++)
{
if(str[n]=='\'')
{
inquote = !inquote;
if(inquote)
str.insert(n++,1,'N');
}
}
HSTMT hStmt;
if(!SQL_SUCCEEDED(m_lasterror=SQLAllocHandle(SQL_HANDLE_STMT,m_hDbc,&hStmt)))
{
SQLFreeStmt(hStmt,SQL_DROP);
return rs;
}
for(std::map<int,CSqlVariant>::iterator i = m_bindVars.begin(); i!=m_bindVars.end(); ++i)
{
switch(i->second.type())
{
case CSqlVariant::vtNull:
m_sqli[i->first]=SQL_NULL_DATA;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,0,0,NULL,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtChar:
CServerIo::trace(3,"Bind vtChar (SQL Server) = \"%c\"",m_sqlv[i->first].c);
m_sqli[i->first]=0;
m_sqlv[i->first].c=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,1,0,&m_sqlv[i->first].c,1,&m_sqli[i->first]);
break;
case CSqlVariant::vtUChar:
m_sqli[i->first]=0;
m_sqlv[i->first].c=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,1,0,&m_sqlv[i->first].c,1,&m_sqli[i->first]);
break;
case CSqlVariant::vtShort:
m_sqli[i->first]=0;
m_sqlv[i->first].s=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_SSHORT,SQL_INTEGER,0,0,&m_sqlv[i->first].s,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtUShort:
m_sqli[i->first]=0;
m_sqlv[i->first].s=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_USHORT,SQL_INTEGER,0,0,&m_sqlv[i->first].s,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtInt:
case CSqlVariant::vtLong:
m_sqli[i->first]=0;
m_sqlv[i->first].l=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_SLONG,SQL_INTEGER,0,0,&m_sqlv[i->first].l,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtUInt:
case CSqlVariant::vtULong:
m_sqli[i->first]=0;
m_sqlv[i->first].l=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_ULONG,SQL_INTEGER,0,0,&m_sqlv[i->first].l,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtLongLong:
m_sqli[i->first]=0;
m_sqlv[i->first].ll=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_SBIGINT,SQL_BIGINT,0,0,&m_sqlv[i->first].ll,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtULongLong:
m_sqli[i->first]=0;
m_sqlv[i->first].ll=i->second;
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_UBIGINT,SQL_BIGINT,0,0,&m_sqlv[i->first].ll,0,&m_sqli[i->first]);
break;
case CSqlVariant::vtString:
CServerIo::trace(3,"Bind vtString (SQL Server)");
if (m_sqlv[i->first].ws.length()+1<256)
{
CServerIo::trace(3,"Bind vtString as type SQL_NTS (Null Terminated String)");
m_sqli[i->first]=SQL_NTS;
m_sqlv[i->first].ws=cvs::wide(i->second);
CServerIo::trace(3,"Bind vtString as SQL_VARCHAR/text C_WCHAR");
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_WCHAR,SQL_VARCHAR,(SQLINTEGER)m_sqlv[i->first].ws.size()+1,0,(SQLPOINTER)m_sqlv[i->first].ws.c_str(),(SQLINTEGER)m_sqlv[i->first].ws.size(),&m_sqli[i->first]);
}
else
{
CServerIo::trace(3,"Bind vtString as type LEN_DATA_AT_EXEC");
m_sqli[i->first]=SQL_LEN_DATA_AT_EXEC((SQLINTEGER)((m_sqlv[i->first].ws.size()+1)*sizeof(wchar_t)));
m_sqlv[i->first].ws=cvs::wide(i->second);
CServerIo::trace(3,"Bind vtString as SQL_WLONGVARCHAR/text BLOB");
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_WCHAR,SQL_WLONGVARCHAR,(SQLINTEGER)((m_sqlv[i->first].ws.size()+1)*sizeof(wchar_t)),0,(VOID *)NULL,0,&m_sqli[i->first]);
}
break;
case CSqlVariant::vtWString:
CServerIo::trace(3,"Bind vtWString (SQL Server)");
m_sqli[i->first]=SQL_NTS;
m_sqlv[i->first].ws=i->second;
CServerIo::trace(3,"Bind vtWString (SQL Server)");
ret = SQLBindParameter(hStmt,i->first+1,SQL_PARAM_INPUT,SQL_C_WCHAR,SQL_WVARCHAR,(SQLINTEGER)m_sqlv[i->first].ws.size()+1,0,(SQLPOINTER)m_sqlv[i->first].ws.c_str(),(SQLINTEGER)m_sqlv[i->first].ws.size()+1,&m_sqli[i->first]);
break;
}
}
CServerIo::trace(3,"%s",str.c_str());
rs->Init(this,hStmt,str.c_str()); // Ignore return... it's handled by the error routines
m_bindVars.clear();
return rs;
}
/*
* must be called after an execute
*/
static int statement_fetch_impl(lua_State *L, statement_t *statement, int named_columns) {
int i;
int d;
SQLCHAR message[SQL_MAX_MESSAGE_LENGTH + 1];
SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1];
SQLINTEGER sqlcode;
SQLSMALLINT length;
SQLRETURN rc = SQL_SUCCESS;
if (!statement->resultset || !statement->bind) {
lua_pushnil(L);
return 1;
}
/* fetch each row, and display */
rc = SQLFetch(statement->stmt);
if (rc == SQL_NO_DATA_FOUND) {
SQLFreeStmt(statement->stmt, SQL_RESET_PARAMS);
lua_pushnil(L);
return 1;
}
if (rc != SQL_SUCCESS) {
SQLGetDiagRec(SQL_HANDLE_STMT, statement->stmt, 1, sqlstate, &sqlcode, message, SQL_MAX_MESSAGE_LENGTH + 1, &length);
luaL_error(L, DBI_ERR_FETCH_FAILED, message);
}
d = 1;
lua_newtable(L);
for (i = 0; i < statement->num_result_columns; i++) {
lua_push_type_t lua_push = db2_to_lua_push(statement->resultset[i].type, statement->bind[i].len);
const char *name = strlower(statement->resultset[i].name);
double val;
char *value = (char *)statement->bind[i].buffer;
switch (lua_push) {
case LUA_PUSH_NIL:
if (named_columns) {
LUA_PUSH_ATTRIB_NIL(name);
} else {
LUA_PUSH_ARRAY_NIL(d);
}
break;
case LUA_PUSH_INTEGER:
if (named_columns) {
LUA_PUSH_ATTRIB_INT(name, atoi(value));
} else {
LUA_PUSH_ARRAY_INT(d, atoi(value));
}
break;
case LUA_PUSH_NUMBER:
val = strtod(value, NULL);
if (named_columns) {
LUA_PUSH_ATTRIB_FLOAT(name, val);
} else {
LUA_PUSH_ARRAY_FLOAT(d, val);
}
break;
case LUA_PUSH_BOOLEAN:
if (named_columns) {
LUA_PUSH_ATTRIB_BOOL(name, atoi(value));
} else {
LUA_PUSH_ARRAY_BOOL(d, atoi(value));
}
break;
case LUA_PUSH_STRING:
if (named_columns) {
LUA_PUSH_ATTRIB_STRING(name, value);
} else {
LUA_PUSH_ARRAY_STRING(d, value);
}
break;
default:
luaL_error(L, DBI_ERR_UNKNOWN_PUSH);
}
}
return 1;
}
/*
---------------------------------------------------------
TestSQLTransact
---------------------------------------------------------
*/
PassFail TestSQLTransact(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
TCHAR Heading[MAX_STRING_SIZE];
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ExecDirStr[6];
UWORD fType[] = { SQL_ROLLBACK,SQL_COMMIT };
TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"),_T("SQL_COMMIT") };
TCHAR *Output;
SQLLEN OutputLen;
struct
{
SWORD ExeRes[2];
SWORD FetchRes[2];
TCHAR *DataRes[2];
} CheckRes[] =
{
{SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")},
{SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}
};
int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLTransact"), charset_file);
if (var_list == NULL) return FAILED;
ExecDirStr[0] = var_mapping(_T("SQLTransact_ExecDirStr_0"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLTransact_ExecDirStr_1"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLTransact_ExecDirStr_2"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLTransact_ExecDirStr_3"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLTransact_ExecDirStr_4"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLTransact_ExecDirStr_5"), var_list);
CheckRes[1].DataRes[1] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[0] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[1] = var_mapping(_T("SQLTransact_Update"), var_list);
CheckRes[3].DataRes[0] = var_mapping(_T("SQLTransact_Update"), var_list);
//========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLTransact.\n"));
TEST_INIT;
TESTCASE_BEGIN("Initializing SQLTransact test environment\n");
//
if(!FullConnect(pTestInfo))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
for (commit_on_off = 0; commit_on_off < 10; commit_on_off++)
{
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_ON);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
SQLExecDirect(hstmt, (SQLTCHAR*)ExecDirStr[4], SQL_NTS); /* CLEANUP */
for (i = 0; i <= (iend-1); i++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is ON and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
for (i = 0; i <= (iend-1); i++)
{
for (j = 0; j <= jend; j++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is OFF and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T(" & "));
_tcscat(Heading, TypeDesc[j]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
//MAY 9, 2014 - TURNING AUTOCOMMIT ON FOR DDLs FOR TRAF, AS DDLs ARE NOT SUPPORTED WITH AUTOCOMMIT OFF
if (i == 4 || i == 0)
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
if (!CHECKRC(SQL_SUCCESS, returncode, "SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,fType[j]);
Sleep(2); // tmf rollback is slower.
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS);
if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO)
{
Output = (TCHAR *)malloc(NAME_LEN);
returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR)
{
if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0)
{
LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]);
}
else
{
LogMsg(NONE,_T("expect: %s and actual: %s are not matched\n"),Output,CheckRes[i].DataRes[j]);
TEST_FAILED;
}
}
}
free(Output);
SQLFreeStmt(hstmt,SQL_CLOSE);
}
}
}
}
TESTCASE_END;
}/* end j loop */
}/* end i loop */
}
//========================================================================================================
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLDisconnect((SQLHANDLE)hdbc);
if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
// Free the open transactions.
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK);
Sleep(2);
returncode=FullDisconnect(pTestInfo);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLTransact.\n"));
free_list(var_list);
TEST_RETURN;
}
/*
* Test program to run on the connected database
*/
int
ODBC_Test ()
{
SQLTCHAR request[4096];
SQLTCHAR fetchBuffer[1024];
char buf[4096];
size_t displayWidths[MAXCOLS];
size_t displayWidth;
short numCols;
short colNum;
SQLTCHAR colName[50];
SQLSMALLINT colType;
SQLULEN colPrecision;
SQLLEN colIndicator;
SQLSMALLINT colScale;
SQLSMALLINT colNullable;
unsigned long totalRows;
unsigned long totalSets;
int i;
SQLRETURN sts;
while (1)
{
/*
* Ask the user for a dynamic SQL statement
*/
printf ("\nSQL>");
if (fgets (buf, sizeof (buf), stdin) == NULL)
break;
#ifndef UNICODE
strcpy ((char *) request, (char *) buf);
#else
strcpy_A2W (request, buf);
#endif
request[TXTLEN (request) - 1] = TEXTC ('\0');
if (request[0] == TEXTC ('\0'))
continue;
/*
* If the user just types tables, give him a list
*/
if (!TXTCMP (request, TEXT ("tables")))
{
if (SQLTables (hstmt, NULL, 0, NULL, 0, NULL, 0,
NULL, 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(tables)");
continue;
}
}
/*
* If the user just types qualifiers, give him a list
*/
else if (!TXTCMP (request, TEXT ("qualifiers")))
{
if (SQLTables (hstmt, TEXT ("%"), SQL_NTS, TEXT (""), 0,
TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(qualifiers)");
continue;
}
}
/*
* If the user just types owners, give him a list
*/
else if (!TXTCMP (request, TEXT ("owners")))
{
if (SQLTables (hstmt, TEXT (""), 0, TEXT ("%"), SQL_NTS,
TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(owners)");
continue;
}
}
/*
* If the user just types "types", give him a list
*/
else if (!TXTCMP (request, TEXT ("types")))
{
if (SQLTables (hstmt, TEXT (""), 0, TEXT (""), 0,
TEXT (""), 0, TEXT ("%"), SQL_NTS) != SQL_SUCCESS)
{
ODBC_Errors ("SQLTables(types)");
continue;
}
}
/*
* If the user just types "datatypes", give him a list
*/
else if (!TXTCMP (request, TEXT ("datatypes")))
{
if (SQLGetTypeInfo (hstmt, 0) != SQL_SUCCESS)
{
ODBC_Errors ("SQLGetTypeInfo");
continue;
}
}
else if (!TXTCMP (request, TEXT ("reconnect")))
{
if (ODBC_Reconnect())
return -1;
continue;
}
#if defined (unix)
else if (!TXTCMP (request, TEXT ("environment")))
{
extern char **environ;
int i;
for (i = 0; environ[i]; i++)
fprintf (stderr, "%03d: [%s]\n", i, environ[i]);
continue;
}
#endif
else if (!TXTCMP (request, TEXT ("quit"))
|| !TXTCMP (request, TEXT ("exit")))
break; /* If you want to quit, just say so */
else
{
/*
* Prepare & Execute the statement
*/
if (SQLPrepare (hstmt, (SQLTCHAR *) request,
SQL_NTS) != SQL_SUCCESS)
{
ODBC_Errors ("SQLPrepare");
continue;
}
if ((sts = SQLExecute (hstmt)) != SQL_SUCCESS)
{
ODBC_Errors ("SQLExec");
if (sts != SQL_SUCCESS_WITH_INFO)
continue;
}
}
/*
* Loop through all the result sets
*/
totalSets = 1;
do
{
/*
* Get the number of result columns for this cursor.
* If it is 0, then the statement was probably a select
*/
if (SQLNumResultCols (hstmt, &numCols) != SQL_SUCCESS)
{
ODBC_Errors ("SQLNumResultCols");
goto endCursor;
}
if (numCols == 0)
{
SQLLEN nrows = 0;
SQLRowCount (hstmt, &nrows);
printf ("Statement executed. %ld rows affected.\n",
nrows > 0 ? (long) nrows : 0L);
goto endCursor;
}
if (numCols > MAXCOLS)
{
numCols = MAXCOLS;
fprintf (stderr,
"NOTE: Resultset truncated to %d columns.\n", MAXCOLS);
}
/*
* Get the names for the columns
*/
putchar ('\n');
for (colNum = 1; colNum <= numCols; colNum++)
{
/*
* Get the name and other type information
*/
if (SQLDescribeCol (hstmt, colNum,
(SQLTCHAR *) colName, NUMTCHAR (colName), NULL,
&colType, &colPrecision, &colScale,
&colNullable) != SQL_SUCCESS)
{
ODBC_Errors ("SQLDescribeCol");
goto endCursor;
}
/*
* Calculate the display width for the column
*/
switch (colType)
{
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_WVARCHAR:
case SQL_WCHAR:
case SQL_GUID:
displayWidth = colPrecision;
break;
case SQL_BINARY:
displayWidth = colPrecision * 2;
break;
case SQL_LONGVARCHAR:
case SQL_WLONGVARCHAR:
case SQL_LONGVARBINARY:
displayWidth = 30; /* show only first 30 */
break;
case SQL_BIT:
displayWidth = 1;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
displayWidth = colPrecision + 1; /* sign */
break;
case SQL_DOUBLE:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_FLOAT:
case SQL_REAL:
displayWidth = colPrecision + 2; /* sign, comma */
break;
#ifdef SQL_TYPE_DATE
case SQL_TYPE_DATE:
#endif
case SQL_DATE:
displayWidth = 10;
break;
#ifdef SQL_TYPE_TIME
case SQL_TYPE_TIME:
#endif
case SQL_TIME:
displayWidth = 8;
break;
#ifdef SQL_TYPE_TIMESTAMP
case SQL_TYPE_TIMESTAMP:
#endif
case SQL_TIMESTAMP:
displayWidth = 19;
if (colScale > 0)
displayWidth = displayWidth + colScale + 1;
break;
default:
displayWidths[colNum - 1] = 0; /* skip other data types */
continue;
}
if (displayWidth < TXTLEN (colName))
displayWidth = TXTLEN (colName);
if (displayWidth > NUMTCHAR (fetchBuffer) - 1)
displayWidth = NUMTCHAR (fetchBuffer) - 1;
displayWidths[colNum - 1] = displayWidth;
/*
* Print header field
*/
#ifdef UNICODE
printf ("%-*.*S", displayWidth, displayWidth, colName);
#else
printf ("%-*.*s", displayWidth, displayWidth, colName);
#endif
if (colNum < numCols)
putchar ('|');
}
putchar ('\n');
/*
* Print second line
*/
for (colNum = 1; colNum <= numCols; colNum++)
{
for (i = 0; i < displayWidths[colNum - 1]; i++)
putchar ('-');
if (colNum < numCols)
putchar ('+');
}
putchar ('\n');
/*
* Print all the fields
*/
totalRows = 0;
while (1)
{
#if (ODBCVER < 0x0300)
int sts = SQLFetch (hstmt);
#else
int sts = SQLFetchScroll (hstmt, SQL_FETCH_NEXT, 1);
#endif
if (sts == SQL_NO_DATA_FOUND)
break;
if (sts != SQL_SUCCESS)
{
ODBC_Errors ("Fetch");
break;
}
for (colNum = 1; colNum <= numCols; colNum++)
{
/*
* Fetch this column as character
*/
#ifdef UNICODE
sts = SQLGetData (hstmt, colNum, SQL_C_WCHAR, fetchBuffer,
NUMTCHAR (fetchBuffer), &colIndicator);
#else
sts = SQLGetData (hstmt, colNum, SQL_C_CHAR, fetchBuffer,
NUMTCHAR (fetchBuffer), &colIndicator);
#endif
if (sts != SQL_SUCCESS_WITH_INFO && sts != SQL_SUCCESS)
{
ODBC_Errors ("SQLGetData");
goto endCursor;
}
/*
* Show NULL fields as ****
*/
if (colIndicator == SQL_NULL_DATA)
{
for (i = 0; i < displayWidths[colNum - 1]; i++)
fetchBuffer[i] = TEXTC ('*');
fetchBuffer[i] = TEXTC ('\0');
}
#ifdef UNICODE
printf ("%-*.*S", displayWidths[colNum - 1],
displayWidths[colNum - 1], fetchBuffer);
#else
printf ("%-*.*s", displayWidths[colNum - 1],
displayWidths[colNum - 1], fetchBuffer);
#endif
if (colNum < numCols)
putchar ('|');
}
putchar ('\n');
totalRows++;
}
printf ("\n result set %lu returned %lu rows.\n\n",
totalSets, totalRows);
totalSets++;
}
while ((sts = SQLMoreResults (hstmt)) == SQL_SUCCESS);
if (sts == SQL_ERROR)
ODBC_Errors ("SQLMoreResults");
endCursor:
#if (ODBCVER < 0x0300)
SQLFreeStmt (hstmt, SQL_CLOSE);
#else
SQLCloseCursor (hstmt);
#endif
}
return 0;
}
/*
* NOTE: the dn must be normalized
*/
int
backsql_dn2id(
Operation *op,
SlapReply *rs,
SQLHDBC dbh,
struct berval *ndn,
backsql_entryID *id,
int matched,
int muck )
{
backsql_info *bi = op->o_bd->be_private;
SQLHSTMT sth = SQL_NULL_HSTMT;
BACKSQL_ROW_NTS row = { 0 };
RETCODE rc;
int res;
struct berval realndn = BER_BVNULL;
/* TimesTen */
char upperdn[ BACKSQL_MAX_DN_LEN + 1 ];
struct berval tbbDN;
int i, j;
/*
* NOTE: id can be NULL; in this case, the function
* simply checks whether the DN can be successfully
* turned into an ID, returning LDAP_SUCCESS for
* positive cases, or the most appropriate error
*/
Debug( LDAP_DEBUG_TRACE, "==>backsql_dn2id(\"%s\")%s%s\n",
ndn->bv_val, id == NULL ? " (no ID expected)" : "",
matched ? " matched expected" : "" );
if ( id ) {
/* NOTE: trap inconsistencies */
assert( BER_BVISNULL( &id->eid_ndn ) );
}
if ( ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_dn2id(\"%s\"): DN length=%ld "
"exceeds max DN length %d:\n",
ndn->bv_val, ndn->bv_len, BACKSQL_MAX_DN_LEN );
return LDAP_OTHER;
}
/* return baseObject if available and matches */
/* FIXME: if ndn is already mucked, we cannot check this */
if ( bi->sql_baseObject != NULL &&
dn_match( ndn, &bi->sql_baseObject->e_nname ) )
{
if ( id != NULL ) {
#ifdef BACKSQL_ARBITRARY_KEY
ber_dupbv_x( &id->eid_id, &backsql_baseObject_bv,
op->o_tmpmemctx );
ber_dupbv_x( &id->eid_keyval, &backsql_baseObject_bv,
op->o_tmpmemctx );
#else /* ! BACKSQL_ARBITRARY_KEY */
id->eid_id = BACKSQL_BASEOBJECT_ID;
id->eid_keyval = BACKSQL_BASEOBJECT_KEYVAL;
#endif /* ! BACKSQL_ARBITRARY_KEY */
id->eid_oc_id = BACKSQL_BASEOBJECT_OC;
ber_dupbv_x( &id->eid_ndn, &bi->sql_baseObject->e_nname,
op->o_tmpmemctx );
ber_dupbv_x( &id->eid_dn, &bi->sql_baseObject->e_name,
op->o_tmpmemctx );
id->eid_next = NULL;
}
return LDAP_SUCCESS;
}
/* begin TimesTen */
Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): id_query \"%s\"\n",
ndn->bv_val, bi->sql_id_query, 0 );
assert( bi->sql_id_query != NULL );
rc = backsql_Prepare( dbh, &sth, bi->sql_id_query, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_dn2id(\"%s\"): "
"error preparing SQL:\n %s",
ndn->bv_val, bi->sql_id_query, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
res = LDAP_OTHER;
goto done;
}
realndn = *ndn;
if ( muck ) {
if ( backsql_api_dn2odbc( op, rs, &realndn ) ) {
Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): "
"backsql_api_dn2odbc(\"%s\") failed\n",
ndn->bv_val, realndn.bv_val, 0 );
res = LDAP_OTHER;
goto done;
}
}
if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
/*
* Prepare an upper cased, byte reversed version
* that can be searched using indexes
*/
for ( i = 0, j = realndn.bv_len - 1; realndn.bv_val[ i ]; i++, j--)
{
upperdn[ i ] = realndn.bv_val[ j ];
}
upperdn[ i ] = '\0';
ldap_pvt_str2upper( upperdn );
Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): "
"upperdn=\"%s\"\n",
ndn->bv_val, upperdn, 0 );
ber_str2bv( upperdn, 0, 0, &tbbDN );
} else {
if ( BACKSQL_USE_REVERSE_DN( bi ) ) {
AC_MEMCPY( upperdn, realndn.bv_val, realndn.bv_len + 1 );
ldap_pvt_str2upper( upperdn );
Debug( LDAP_DEBUG_TRACE,
" backsql_dn2id(\"%s\"): "
"upperdn=\"%s\"\n",
ndn->bv_val, upperdn, 0 );
ber_str2bv( upperdn, 0, 0, &tbbDN );
} else {
tbbDN = realndn;
}
}
rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, &tbbDN );
if ( rc != SQL_SUCCESS) {
/* end TimesTen */
Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): "
"error binding dn=\"%s\" parameter:\n",
ndn->bv_val, tbbDN.bv_val, 0 );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
res = LDAP_OTHER;
goto done;
}
rc = SQLExecute( sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): "
"error executing query (\"%s\", \"%s\"):\n",
ndn->bv_val, bi->sql_id_query, tbbDN.bv_val );
backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
res = LDAP_OTHER;
goto done;
}
backsql_BindRowAsStrings_x( sth, &row, op->o_tmpmemctx );
rc = SQLFetch( sth );
if ( BACKSQL_SUCCESS( rc ) ) {
char buf[ SLAP_TEXT_BUFLEN ];
#ifdef LDAP_DEBUG
snprintf( buf, sizeof(buf),
"id=%s keyval=%s oc_id=%s dn=%s",
row.cols[ 0 ], row.cols[ 1 ],
row.cols[ 2 ], row.cols[ 3 ] );
Debug( LDAP_DEBUG_TRACE,
" backsql_dn2id(\"%s\"): %s\n",
ndn->bv_val, buf, 0 );
#endif /* LDAP_DEBUG */
res = LDAP_SUCCESS;
if ( id != NULL ) {
struct berval dn;
id->eid_next = NULL;
#ifdef BACKSQL_ARBITRARY_KEY
ber_str2bv_x( row.cols[ 0 ], 0, 1, &id->eid_id,
op->o_tmpmemctx );
ber_str2bv_x( row.cols[ 1 ], 0, 1, &id->eid_keyval,
op->o_tmpmemctx );
#else /* ! BACKSQL_ARBITRARY_KEY */
if ( lutil_atoulx( &id->eid_id, row.cols[ 0 ], 0 ) != 0 ) {
res = LDAP_OTHER;
goto done;
}
if ( lutil_atoulx( &id->eid_keyval, row.cols[ 1 ], 0 ) != 0 ) {
res = LDAP_OTHER;
goto done;
}
#endif /* ! BACKSQL_ARBITRARY_KEY */
if ( lutil_atoulx( &id->eid_oc_id, row.cols[ 2 ], 0 ) != 0 ) {
res = LDAP_OTHER;
goto done;
}
ber_str2bv( row.cols[ 3 ], 0, 0, &dn );
if ( backsql_api_odbc2dn( op, rs, &dn ) ) {
res = LDAP_OTHER;
goto done;
}
res = dnPrettyNormal( NULL, &dn,
&id->eid_dn, &id->eid_ndn,
op->o_tmpmemctx );
if ( res != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
" backsql_dn2id(\"%s\"): "
"dnPrettyNormal failed (%d: %s)\n",
realndn.bv_val, res,
ldap_err2string( res ) );
/* cleanup... */
(void)backsql_free_entryID( id, 0, op->o_tmpmemctx );
}
if ( dn.bv_val != row.cols[ 3 ] ) {
free( dn.bv_val );
}
}
} else {
res = LDAP_NO_SUCH_OBJECT;
if ( matched ) {
struct berval pdn = *ndn;
/*
* Look for matched
*/
rs->sr_matched = NULL;
while ( !be_issuffix( op->o_bd, &pdn ) ) {
char *matchedDN = NULL;
dnParent( &pdn, &pdn );
/*
* Empty DN ("") defaults to LDAP_SUCCESS
*/
rs->sr_err = backsql_dn2id( op, rs, dbh, &pdn, id, 0, 1 );
switch ( rs->sr_err ) {
case LDAP_NO_SUCH_OBJECT:
/* try another one */
break;
case LDAP_SUCCESS:
matchedDN = pdn.bv_val;
/* fail over to next case */
default:
rs->sr_err = LDAP_NO_SUCH_OBJECT;
rs->sr_matched = matchedDN;
goto done;
}
}
}
}
done:;
backsql_FreeRow_x( &row, op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE,
"<==backsql_dn2id(\"%s\"): err=%d\n",
ndn->bv_val, res, 0 );
if ( sth != SQL_NULL_HSTMT ) {
SQLFreeStmt( sth, SQL_DROP );
}
if ( !BER_BVISNULL( &realndn ) && realndn.bv_val != ndn->bv_val ) {
ch_free( realndn.bv_val );
}
return res;
}
