Exemplo n.º 1
0
	// 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;
		}
	}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
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;
}
Exemplo n.º 4
0
/*
 * 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;
}
Exemplo n.º 5
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 */
Exemplo n.º 6
0
/* 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 */
Exemplo n.º 7
0
Arquivo: lenv.c Projeto: ld-test/odbc
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);
}
Exemplo n.º 8
0
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);
}
Exemplo n.º 9
0
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);
	}
}
Exemplo n.º 10
0
/*
** 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);
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
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);
}
Exemplo n.º 14
0
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);
}
Exemplo n.º 15
0
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);
			}
		}
Exemplo n.º 17
0
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
}
Exemplo n.º 19
0
/* 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;
}
Exemplo n.º 20
0
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);

}
Exemplo n.º 21
0
Arquivo: lenv.c Projeto: ld-test/odbc
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;
}
Exemplo n.º 22
0
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);
}
Exemplo n.º 23
0
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;
}
Exemplo n.º 24
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;
}
Exemplo n.º 25
0
/*
** 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;
}
Exemplo n.º 26
0
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);
}
Exemplo n.º 27
0
/* 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);
}
Exemplo n.º 28
0
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;
}
Exemplo n.º 29
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;
}
Exemplo n.º 30
0
/* ------------------------------------------------------------- */
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);

}