RETCODE SQL_API
SQLFreeStmt(HSTMT StatementHandle,
SQLUSMALLINT Option)
{
RETCODE ret;
mylog("[SQLFreeStmt]");
ret = PGAPI_FreeStmt(StatementHandle, Option);
return ret;
}
/* New function */
RETCODE SQL_API
SQLCloseCursor(HSTMT StatementHandle)
{
CSTR func = "SQLCloseCursor";
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
mylog("[[%s]]", func);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
ret = PGAPI_FreeStmt(StatementHandle, SQL_CLOSE);
ret = DiscardStatementSvp(stmt,ret, FALSE);
LEAVE_STMT_CS(stmt);
return ret;
}
RETCODE SQL_API
SQLFreeStmt(HSTMT StatementHandle,
SQLUSMALLINT Option)
{
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn = NULL;
mylog("[SQLFreeStmt]");
if (stmt)
{
if (Option == SQL_DROP)
{
conn = stmt->hdbc;
if (conn)
ENTER_CONN_CS(conn);
}
else
ENTER_STMT_CS(stmt);
}
ret = PGAPI_FreeStmt(StatementHandle, Option);
if (stmt)
{
if (Option == SQL_DROP)
{
if (conn)
LEAVE_CONN_CS(conn);
}
else
LEAVE_STMT_CS(stmt);
}
return ret;
}
static char *
CC_lookup_cs_old(ConnectionClass *self)
{
char *encstr = NULL;
HSTMT hstmt;
RETCODE result;
result = PGAPI_AllocStmt(self, &hstmt);
if (!SQL_SUCCEEDED(result))
return encstr;
result = PGAPI_ExecDirect(hstmt, "Show Client_Encoding", SQL_NTS, 0);
if (result == SQL_SUCCESS_WITH_INFO)
{
char sqlState[8], errormsg[128], enc[32];
if (PGAPI_Error(NULL, NULL, hstmt, sqlState, NULL, errormsg,
sizeof(errormsg), NULL) == SQL_SUCCESS &&
sscanf(errormsg, "%*s %*s %*s %*s %*s %s", enc) > 0)
encstr = strdup(enc);
}
PGAPI_FreeStmt(hstmt, SQL_DROP);
return encstr;
}
RETCODE SQL_API
PGAPI_Cancel(
HSTMT hstmt) /* Statement to cancel. */
{
CSTR func = "PGAPI_Cancel";
StatementClass *stmt = (StatementClass *) hstmt, *estmt;
ConnectionClass *conn;
RETCODE ret = SQL_SUCCESS;
BOOL entered_cs = FALSE;
mylog("%s: entering...\n", func);
/* Check if this can handle canceling in the middle of a SQLPutData? */
if (!stmt)
{
SC_log_error(func, "", NULL);
return SQL_INVALID_HANDLE;
}
conn = SC_get_conn(stmt);
#define return DONT_CALL_RETURN_FROM_HERE???
/* StartRollbackState(stmt); */
if (stmt->execute_delegate)
estmt = stmt->execute_delegate;
else
estmt = stmt;
/*
* Not in the middle of SQLParamData/SQLPutData so cancel like a
* close.
*/
if (estmt->data_at_exec < 0)
{
/*
* Tell the Backend that we're cancelling this request
*/
if (estmt->status == STMT_EXECUTING)
{
if (!CC_send_cancel_request(conn))
{
ret = SQL_ERROR;
}
goto cleanup;
}
/*
* MAJOR HACK for Windows to reset the driver manager's cursor
* state: Because of what seems like a bug in the Odbc driver
* manager, SQLCancel does not act like a SQLFreeStmt(CLOSE), as
* many applications depend on this behavior. So, this brute
* force method calls the driver manager's function on behalf of
* the application.
*/
if (conn->driver_version < 0x0350)
{
#ifdef WIN32
ConnInfo *ci = &(conn->connInfo);
if (ci->drivers.cancel_as_freestmt)
{
typedef SQLRETURN (SQL_API *SQLAPIPROC)();
HMODULE hmodule;
SQLAPIPROC addr;
hmodule = GetModuleHandle("ODBC32");
addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLFreeStmt");
ret = addr((char *) (stmt->phstmt) - 96, SQL_CLOSE);
}
else
#endif /* WIN32 */
{
ENTER_STMT_CS(stmt);
entered_cs = TRUE;
SC_clear_error(hstmt);
ret = PGAPI_FreeStmt(hstmt, SQL_CLOSE);
}
mylog("PGAPI_Cancel: PGAPI_FreeStmt returned %d\n", ret);
}
goto cleanup;
}
/* In the middle of SQLParamData/SQLPutData, so cancel that. */
/*
* Note, any previous data-at-exec buffers will be freed in the
* recycle
*/
/* if they call SQLExecDirect or SQLExecute again. */
ENTER_STMT_CS(stmt);
entered_cs = TRUE;
SC_clear_error(stmt);
estmt->data_at_exec = -1;
estmt->current_exec_param = -1;
estmt->put_data = FALSE;
cancelNeedDataState(estmt);
cleanup:
#undef return
if (entered_cs)
{
if (stmt->internal)
ret = DiscardStatementSvp(stmt, ret, FALSE);
LEAVE_STMT_CS(stmt);
}
return ret;
}
