// Close statement void statement::close() { if (is_open()) { // Free parameters param_it it; for(it = m_params.begin();it != m_params.end();it++) delete it->second; m_params.clear(); // Free result if any free_results(); // Free handle SQLFreeHandle(SQL_HANDLE_STMT, stmt_h); stmt_h = NULL; b_open = false; } }
static int odbc_do_query(void) { int ODBC_res; ODBC_res = SQLExecute(ODBC_stmt); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error in Query %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt); odbc_disconnect(); return -1; } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query Successful!\n"); connected = 1; } return 0; }
bool ODBCSession::Connect(const char *cs) { if(henv && IsOk(SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc))) { if(IsOk(SQLDriverConnect(hdbc, NULL, (SQLCHAR *)cs, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT))) { SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); if(tmode == NORMAL) SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS); SQLSetConnectAttr(hdbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TRANSACTION_SERIALIZABLE, SQL_NTS); Sql sql("select cast(current_user as text)", *this); if(sql.Execute() && sql.Fetch()) user = sql[0]; return true; } SQLFreeHandle(SQL_HANDLE_DBC, hdbc); hdbc = SQL_NULL_HANDLE; } return false; }
/* * Release a result set from memory */ int db_unixodbc_free_result(db_con_t* _h, db_res_t* _r) { if ((!_h) || (!_r)) { LM_ERR("invalid parameter value\n"); return -1; } if (db_free_result(_r) < 0) { LM_ERR("failed to free result structure\n"); return -1; } SQLFreeHandle(SQL_HANDLE_STMT, CON_RESULT(_h)); CON_RESULT(_h) = NULL; return 0; }
void sql_free(int cid) { struct OCURS *o = findCursor(cid); if(o->flag == CURSOR_OPENED) sql_close(cid); stmt_text = "free"; debugStatement(); hstmt = o->hstmt; rc = SQLFreeHandle(SQL_HANDLE_STMT, hstmt); o->flag = CURSOR_NONE; o->hstmt = SQL_NULL_HSTMT; rv_numRets = 0; memset(rv_type, 0, sizeof (rv_type)); /* free should never fail */ errorTrap(0); exclist = 0; } /* sql_free */
/* You must call this with args of 0,0 */ static long oneRetValue(void *pre_x, ...) { char coltype = rv_type[0]; char c; long n; double f; void **x = (void **)((char *)&pre_x + 4); va_end(sqlargs); if(rv_numRets != 1) errorPrint("2SQL statement has %d return values, 1 value expected", rv_numRets); if(!strchr("MNFDICS", coltype)) errorPrint ("2SQL statement returns a value whose type is not compatible with a 4-byte integer"); va_start(sqlargs, pre_x); /* I'm not sure float to int really works. */ if(coltype == 'F') { *x = &f; retsFromOdbc(); n = f; } else if(coltype == 'S') { *x = retstring[0]; retsFromOdbc(); if(!stringIsNum(retstring[0])) errorPrint ("2SQL statement returns a string %s that cannot be converted into a 4-byte integer", retstring[0]); n = atoi(retstring[0]); } else if(coltype == 'C') { *x = &c; retsFromOdbc(); n = c; } else { *x = &n; retsFromOdbc(); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt); return n; } /* oneRetValue */
static int env_destroy (lua_State *L) { lodbc_env *env = (lodbc_env *)lutil_checkudatap (L, 1, LODBC_ENV); luaL_argcheck (L, env != NULL, 1, LODBC_PREFIX "environment expected"); if(!(env->flags & LODBC_FLAG_DESTROYED)) { if(LUA_NOREF != env->conn_list_ref) { lua_rawgeti(L, LODBC_LUA_REGISTRY, env->conn_list_ref); assert(lua_istable(L, -1)); lua_pushnil(L); while(lua_next(L, -2)) { lua_pop(L, 1); // we do not need value call_cnn_destroy(L); } } if (env->conn_counter > 0) return luaL_error (L, LODBC_PREFIX"there are open connections"); if(!(env->flags & LODBC_FLAG_DONT_DESTROY)) { #ifdef LODBC_CHECK_ERROR_ON_DESTROY SQLRETURN ret = #endif SQLFreeHandle (hENV, env->handle); #ifdef LODBC_CHECK_ERROR_ON_DESTROY if (lodbc_iserror(ret)) return lodbc_fail(L, hENV, env->handle); #endif env->handle = SQL_NULL_HANDLE; } luaL_unref(L, LODBC_LUA_REGISTRY, env->conn_list_ref); env->conn_list_ref = LUA_NOREF; env->flags |= LODBC_FLAG_DESTROYED; } lua_pushnil(L); lodbc_set_user_value(L, 1); return lodbc_pass(L); }
void create_proc () { HSTMT hstmt; SQLRETURN rc; rc = SQLAllocHandle (SQL_HANDLE_STMT, (SQLHANDLE) hdbc, (SQLHANDLE *) & hstmt); if (rc != SQL_SUCCESS) { err_printf ("SQLAllocHandle() failed.\n"); exit (1); } rc = SQLExecDirect (hstmt, "create procedure burstoff_proc () { ; }", SQL_NTS); if (rc != SQL_SUCCESS) { printf ("drop table failed.\n"); error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); } rc = SQLExecDirect (hstmt, "create procedure burstoff_rs_proc (in ntimes integer := 3)\n" "{\n" " declare ret varchar;\n" " result_names (ret);\n" " declare i,x integer;\n" " i := 0;\n" " while (i < ntimes)\n" " {\n" " result (repeat (' ', 8000));\n" " select count (*) into x from DB.DBA.SYS_COLS k1, DB.DBA.SYS_KEYS k2, DB.DBA.SYS_USERS k3;\n" " i := i + 1;\n" " }\n" "}", SQL_NTS); if (rc != SQL_SUCCESS) { printf ("drop table failed.\n"); error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); } SQLFreeHandle (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); }
static void sql_odbc_free_result(t_sql_res *result) { if(result) { t_odbc_res *res = (t_odbc_res*)result; if(res->stmt) { SQLFreeHandle(SQL_HANDLE_STMT, res->stmt); res->stmt = NULL; } if(res->rowSet) { t_odbc_rowSet *rowSet = res->rowSet; while(rowSet) { t_odbc_rowSet *temp = (rowSet->next); sql_odbc_free_fields(rowSet->row); xfree(rowSet); rowSet = temp; } } xfree(result); } }
/* ** Closes an environment object */ static int env_close (lua_State *L) { SQLRETURN ret; env_data *env = (env_data *)luaL_checkudata(L, 1, LUASQL_ENVIRONMENT_ODBC); luaL_argcheck (L, env != NULL, 1, LUASQL_PREFIX"environment expected"); if (env->closed) { lua_pushboolean (L, 0); return 1; } if (env->conn_counter > 0) return luaL_error (L, LUASQL_PREFIX"there are open connections"); env->closed = 1; ret = SQLFreeHandle (hENV, env->henv); if (error(ret)) { int ret = fail(L, hENV, env->henv); env->henv = NULL; return ret; } return pass(L); }
CDbLib::CDbLib() { myHENV = 0; SetTimeout(DEFAULT_TIMEOUT); SQLSetEnvAttr(0, SQL_ATTR_CONNECTION_POOLING, (SQLPOINTER) SQL_CP_ONE_PER_HENV, 0); if (SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&myHENV) != SQL_SUCCESS) { myHENV = 0; } else { if (SQLSetEnvAttr(myHENV, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER) != SQL_SUCCESS) { SQLFreeHandle(SQL_HANDLE_ENV, myHENV); myHENV = 0; } } myMaxBuffer = DEFAULT_MAX_BUFFER; }
static int odbc_stmt_dtor(pdo_stmt_t *stmt) { pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data; if (S->stmt != SQL_NULL_HANDLE) { if (stmt->executed) { SQLCloseCursor(S->stmt); } SQLFreeHandle(SQL_HANDLE_STMT, S->stmt); S->stmt = SQL_NULL_HANDLE; } free_cols(stmt, S); if (S->convbuf) { efree(S->convbuf); } efree(S); return 1; }
void DSN_Set_CharacterSets(SQLHANDLE Connection) { MADB_Stmt *Stmt= NULL; SQLRETURN ret= SQL_ERROR; char Charset[65]; MADB_Dsn *Dsn= (MADB_Dsn *)GetWindowLongPtr(GetParent(hwndTab[0]), DWLP_USER); if (CSFilled) return; GetDialogFields(); if (SQLAllocHandle(SQL_HANDLE_STMT, Connection, (SQLHANDLE *)&Stmt) != SQL_SUCCESS) goto end; if (SQLExecDirect((SQLHSTMT)Stmt, (SQLCHAR *)"select character_set_name from information_schema.collations " "WHERE character_set_name NOT LIKE 'utf16%' AND " "character_set_name NOT LIKE 'utf32%' AND " "character_set_name NOT LIKE 'ucs2' " "group by character_set_name order by character_set_name" , SQL_NTS) != SQL_SUCCESS) goto end; SQLBindCol(Stmt, 1, SQL_C_CHAR, Charset, 65, 0); ComboBox_ResetContent(GetDlgItem(hwndTab[2], cbCharset)); while (SQLFetch(Stmt) == SQL_SUCCESS) ComboBox_InsertString(GetDlgItem(hwndTab[2], cbCharset), -1, Charset); if (Dsn->CharacterSet) { int Idx= ComboBox_FindString(GetDlgItem(hwndTab[2], cbCharset), 0, Dsn->CharacterSet); ComboBox_SetCurSel(GetDlgItem(hwndTab[2], cbCharset), Idx); } ComboBox_SetMinVisible(GetDlgItem(hwndTab[2], cbCharset),5); CSFilled= TRUE; end: if (Stmt) SQLFreeHandle(SQL_HANDLE_STMT, (SQLHANDLE)Stmt); }
void DBConnection::executeUpdate(const char* sql) { _idle = false; SQLHSTMT hstmt = NULL; result = SQLAllocHandle(SQL_HANDLE_STMT,this->dbc,&hstmt); std::string sqlstr = sql; std::string& sqlstr2 = sqlstr; std::wstring wsql = s2ws(sqlstr2); result = SQLExecDirect(hstmt,(SQLWCHAR*)wsql.c_str(),SQL_NTS); if (result != SQL_SUCCESS) { showDBSError(hstmt); } result = SQLEndTran(SQL_HANDLE_DBC,dbc,SQL_COMMIT); if (result != SQL_SUCCESS) { showDBCError(dbc); } SQLFreeHandle(SQL_HANDLE_STMT,hstmt); }
void TableAdmin::Edit( int line, StructAdmin StrAdmin, SQLHDBC hdbc_loc ) { if( !( hasInit && line < SA_count ) ) return; // edit a record char temp[ 1024 ]; sprintf( temp, "update Admin set canManageAdmin = %d, canManageStudent = %d, canSetProblem = %d, canSetPaper = %d, " "canSetExam = %d, canDeleteGrade = %d, canEditGrade = %d where AdminName = \'%s\';", StrAdmin.canManageAdmin ? 1 : 0, StrAdmin.canManageStudent ? 1 : 0, StrAdmin.canSetProblem ? 1 : 0, StrAdmin.canSetPaper ? 1 : 0, StrAdmin.canSetExam ? 1 : 0, StrAdmin.canDeleteGrade ? 1 : 0, StrAdmin.canEditGrade ? 1 : 0, StrAdmin.Name ); SQLHSTMT h; SQLAllocHandle( SQL_HANDLE_STMT, hdbc_loc, &h ); SQLExecDirectA( h, (SQLCHAR *)temp, SQL_NTS ); SQLFreeHandle( SQL_HANDLE_STMT, h ); delete [ ] SA; Init( hdbc_loc, AdminName, PasswordHash ); return; }
connection::connection(const connection_config& config) : _handle(new detail::connection_handle_t(config.debug, config.type)) { if(_handle->debug) { std::cerr << "ODBC debug: connecting to DSN: " << config.data_source_name << std::endl; } if(!SQL_SUCCEEDED(SQLConnect(_handle->dbc, make_sqlchar(config.data_source_name), config.data_source_name.length(), config.username.empty() ? nullptr : make_sqlchar(config.username), config.username.length(), config.password.empty() ? nullptr : make_sqlchar(config.password), config.password.length()))) { std::string err = detail::odbc_error(_handle->dbc, SQL_HANDLE_DBC); //Free and nullify so we don't try to disconnect if(_handle->dbc) { auto d = _handle->dbc; _handle->dbc = nullptr; SQLFreeHandle(SQL_HANDLE_DBC, d); } throw sqlpp::exception("ODBC error: couldn't SQLConnect("+config.data_source_name+"): "+err); } }
static zend_long odbc_handle_doer(pdo_dbh_t *dbh, const char *sql, size_t sql_len) { pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data; RETCODE rc; SQLLEN row_count = -1; PDO_ODBC_HSTMT stmt; rc = SQLAllocHandle(SQL_HANDLE_STMT, H->dbc, &stmt); if (rc != SQL_SUCCESS) { pdo_odbc_drv_error("SQLAllocHandle: STMT"); return -1; } rc = SQLExecDirect(stmt, (char *)sql, sql_len); if (rc == SQL_NO_DATA) { /* If SQLExecDirect executes a searched update or delete statement that * does not affect any rows at the data source, the call to * SQLExecDirect returns SQL_NO_DATA. */ row_count = 0; goto out; } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_doer_error("SQLExecDirect"); goto out; } rc = SQLRowCount(stmt, &row_count); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { pdo_odbc_doer_error("SQLRowCount"); goto out; } if (row_count == -1) { row_count = 0; } out: SQLFreeHandle(SQL_HANDLE_STMT, stmt); return row_count; }
bool OdbcOutput::Write( const mr_utils::mr_string& str ) { #if defined (_WIN32) mr_utils::mr_exception::assertCondition(this->m_odbcEnv != SQL_NULL_HENV, _FL_, _L_("No DB Connection")); SQLHSTMT stmt; SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_STMT, this->m_odbcHdbc, &stmt); mr_utils::mr_exception::assertCondition( ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO, _FL_, _L_("Failed to allocate ODBC statement handle") ); ret = SQLExecDirect(stmt, const_cast<SQLTCHAR*>(str.c_str()), SQL_NTS); if (ret == SQL_ERROR) { //assert(ret == SQL_SUCCESS); SQLTCHAR buffer[SQL_MAX_MESSAGE_LENGTH + 1]; SQLTCHAR sqlstate[SQL_SQLSTATE_SIZE + 1]; SQLINTEGER sqlcode; SQLSMALLINT length; while (SQLError(this->m_odbcEnv, this->m_odbcHdbc, stmt, sqlstate, &sqlcode, buffer, SQL_MAX_MESSAGE_LENGTH + 1, &length) == SQL_SUCCESS) { mr_cout << std::endl << L("**** ERROR *****") << std::endl; mr_cout << L("SQLSTATE:") << sqlstate << std::endl; mr_cout << L("Native Error Code:") << sqlcode << std::endl; mr_cout << buffer << std::endl; }; } /// @todo if SQL_SUCCESS_WITH_INFO or SQL_ERROR we can get the error info before closing handle. SQLFreeHandle(SQL_HANDLE_STMT, stmt); return ret == SQL_SUCCESS; #else return false; #endif }
/* Initialize ODBC environment handle and the database connect string. */ int _db_init(char *sname, char *uname, char *auth) { SQLRETURN rc; /* Initialized the environment handle. */ rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ERROR_MESSAGE("alloc env handle failed"); return ERROR; } rc = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { SQLFreeHandle(SQL_HANDLE_ENV, henv); return ERROR; } /* Set the database connect string, username and password. */ strcpy(servername, sname); strcpy(username, uname); strcpy(authentication, auth); return OK; }
void DBConnection::executeQuery(const char* sql, OdbcDataMap* dm) { _idle = false; SQLHSTMT hstmt = NULL; result = SQLAllocHandle(SQL_HANDLE_STMT,this->dbc,&hstmt); if (result != SQL_SUCCESS) { showDBSError(hstmt); } std::string sqlstr = sql; std::string& sqlstr2 = sqlstr; std::wstring wsql = s2ws(sqlstr2); result = SQLExecDirect(hstmt,(SQLWCHAR*)wsql.c_str(),SQL_NTS); if (result != SQL_SUCCESS) { showDBSError(hstmt); } SQLHSTMT& _hstmt = hstmt; dm->init(hstmt); SQLFreeHandle(SQL_HANDLE_STMT,hstmt); }
int lodbc_environment_create(lua_State *L, SQLHENV henv, uchar own) { lodbc_env *env; uchar is_new = 0; if(henv == SQL_NULL_HANDLE) { SQLRETURN ret = SQLAllocHandle(hENV, SQL_NULL_HANDLE, &henv); if (lodbc_iserror(ret)) return lodbc_faildirect(L, "error creating environment."); own = 1; is_new = 1; } env = lutil_newudatap(L, lodbc_env, LODBC_ENV); memset(env, 0, sizeof(lodbc_env)); if(!own)env->flags |= LODBC_FLAG_DONT_DESTROY; env->handle = henv; env->conn_list_ref = LUA_NOREF; if(LODBC_OPT_INT(ENV_AUTOCLOSECNN)) { int top = lua_gettop(L); lua_pushvalue(L, -1); lua_pushboolean(L, 1); lodbc_pcall_method(L, "setautoclosecnn", 1, 0, 0); lua_settop(L, top); } if(is_new) { int top = lua_gettop(L); SQLRETURN ret = env_set_uint_attr_(L, env, SQL_ATTR_ODBC_VERSION, LODBC_ODBC3_C(SQL_OV_ODBC3, SQL_OV_ODBC2) ); if(lodbc_is_fail(L,ret)) { SQLFreeHandle (hENV, henv); env->flags &= ~LODBC_FLAG_DESTROYED; return ret; } lua_settop(L, top); } return 1; }
inline void GetColumnSize(Connection* cnxn, SQLSMALLINT sqltype, int* psize) { // For some reason I can't seem to reuse the HSTMT multiple times in a row here. Until I // figure it out I'll simply allocate a new one each time. HSTMT hstmt; if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, cnxn->hdbc, &hstmt))) return; SQLINTEGER columnsize; if (SQL_SUCCEEDED(SQLGetTypeInfo(hstmt, sqltype)) && SQL_SUCCEEDED(SQLFetch(hstmt)) && SQL_SUCCEEDED(SQLGetData(hstmt, 3, SQL_INTEGER, &columnsize, sizeof(columnsize), 0))) { // I believe some drivers are returning negative numbers for "unlimited" text fields, // such as FileMaker. Ignore anything that seems too small. if (columnsize >= 1) *psize = (int)columnsize; } SQLFreeStmt(hstmt, SQL_CLOSE); SQLFreeHandle(SQL_HANDLE_STMT, hstmt); }
static int odbc_do_query(void) { long int ODBC_err; int ODBC_res; short int ODBC_mlen; char ODBC_msg[200], ODBC_stat[10]; ODBC_res = SQLExecute(ODBC_stmt); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error in Query %d\n", ODBC_res); SQLGetDiagRec(SQL_HANDLE_DBC, ODBC_con, 1, ODBC_stat, &ODBC_err, ODBC_msg, 100, &ODBC_mlen); SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt); connected = 0; return -1; } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query Successful!\n"); connected = 1; } return 0; }
static int sql_odbc_query(const char *query) { int result; HSTMT stmt = SQL_NULL_HSTMT; /* Validate query. */ if(query == NULL) { eventlog(eventlog_level_error, __FUNCTION__, "Got a NULL query!"); return -1; } // eventlog(eventlog_level_trace, __FUNCTION__, "%s", query); SQLAllocStmt(con, &stmt); result = odbc_Result(SQLExecDirect(stmt, (SQLCHAR*)query, SQL_NTS)); if(result) { SQLRowCount(stmt, &ROWCOUNT); } else { // odbc_Error(SQL_HANDLE_STMT, stmt, eventlog_level_trace, __FUNCTION__); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); result = result == -1 ? 0 : -1; return result; }
/* ** Creates an Environment and returns it. */ static int create_environment (lua_State *L) { env_data *env; SQLHENV henv; SQLRETURN ret = SQLAllocHandle(hENV, SQL_NULL_HANDLE, &henv); if (error(ret)) return luasql_faildirect(L, "error creating environment."); ret = SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (error(ret)) { ret = luasql_faildirect (L, "error setting SQL version."); SQLFreeHandle (hENV, henv); return ret; } env = (env_data *)lua_newuserdata (L, sizeof (env_data)); luasql_setmeta (L, LUASQL_ENVIRONMENT_ODBC); /* fill in structure */ env->closed = 0; env->conn_counter = 0; env->henv = henv; return 1; }
void call_proc (int n_times) { HSTMT hstmt; SQLRETURN rc; int i; rc = SQLAllocHandle (SQL_HANDLE_STMT, (SQLHANDLE) hdbc, (SQLHANDLE *) & hstmt); if (rc != SQL_SUCCESS) { err_printf ("SQLAllocHandle() failed.\n"); exit (1); } rc = SQLPrepare (hstmt, "burstoff_proc()", SQL_NTS); if (rc != SQL_SUCCESS) { err_printf ("prepare failed.\n"); error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); exit (1); } for (i = 0; i < n_times; i++) { rc = SQLExecute (hstmt); if (rc != SQL_SUCCESS) { err_printf ("exec %d failed.\n", i + 1); error (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); exit (1); } } SQLFreeHandle (SQL_HANDLE_STMT, (SQLHANDLE) hstmt); }
/* in zbxdb.h - #define DBfree_result IBM_DB2free_result */ void IBM_DB2free_result(DB_RESULT result) { if (NULL == result) return; if (NULL != result->values_cli) { int i; for (i = 0; i < result->nalloc; i++) { zbx_free(result->values_cli[i]); } zbx_free(result->values); zbx_free(result->values_cli); zbx_free(result->values_len); } if (result->hstmt) SQLFreeHandle(SQL_HANDLE_STMT, result->hstmt); zbx_free(result); }
static int odbc_log(struct ast_cdr *cdr) { struct odbc_obj *obj = ast_odbc_request_obj(dsn, 0); SQLHSTMT stmt; if (!obj) { ast_log(LOG_ERROR, "Unable to retrieve database handle. CDR failed.\n"); return -1; } stmt = ast_odbc_direct_execute(obj, execute_cb, cdr); if (stmt) { SQLLEN rows = 0; SQLRowCount(stmt, &rows); SQLFreeHandle(SQL_HANDLE_STMT, stmt); if (rows == 0) ast_log(LOG_WARNING, "CDR successfully ran, but inserted 0 rows?\n"); } else ast_log(LOG_ERROR, "CDR direct execute failed\n"); ast_odbc_release_obj(obj); return 0; }
static SQLHSTMT generic_prepare(struct odbc_obj *obj, void *data) { struct generic_prepare_struct *gps = data; SQLHSTMT stmt; int res; res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt); if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n"); return NULL; } res = SQLPrepare(stmt, (unsigned char *)gps->sql, SQL_NTS); if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", (char *)gps->sql); SQLFreeHandle(SQL_HANDLE_STMT, stmt); return NULL; } if (!ast_strlen_zero(gps->param)) SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(gps->param), 0, (void *)gps->param, 0, NULL); return stmt; }
/* ------------------------------------------------------------- */ void jx_sqlClose (PJXSQL * ppSQL) { int i; int rc; PJXSQL pSQL = * ppSQL; // Do we have an active statement ... if (pSQL) { // free data buffers for (i = 0; i < pSQL->nresultcols; i++) { PJXCOL pCol = &pSQL->cols[i]; // if ( pCol->coltype != SQL_BLOB) { free (pCol->data); //} } /*------- if (pSQL->hstmt) { rc = SQLFreeStmt(pSQL->hstmt, SQL_CLOSE); } ---*/ if (pSQL->hstmt) { rc = SQLFreeHandle (SQL_HANDLE_STMT, pSQL->hstmt); } if (pSQL->sqlstmt) { free (pSQL->sqlstmt); } } memFree(ppSQL); }