/*
* Release a result set from memory
*/
int db_mongodb_free_result(db1_con_t* _h, db1_res_t* _r)
{
if(!_r)
return -1;
if(RES_PTR(_r)) {
if(((db_mongodb_result_t*)RES_PTR(_r))->rdoc) {
bson_destroy(((db_mongodb_result_t*)RES_PTR(_r))->rdoc);
((db_mongodb_result_t*)RES_PTR(_r))->rdoc = NULL;
}
if(((db_mongodb_result_t*)RES_PTR(_r))->colsdoc) {
bson_destroy (((db_mongodb_result_t*)RES_PTR(_r))->colsdoc);
((db_mongodb_result_t*)RES_PTR(_r))->colsdoc = NULL;
}
((db_mongodb_result_t*)RES_PTR(_r))->nrcols = 0;
if(((db_mongodb_result_t*)RES_PTR(_r))->cursor) {
mongoc_cursor_destroy (((db_mongodb_result_t*)RES_PTR(_r))->cursor);
((db_mongodb_result_t*)RES_PTR(_r))->cursor = NULL;
}
if(((db_mongodb_result_t*)RES_PTR(_r))->collection) {
mongoc_collection_destroy (((db_mongodb_result_t*)RES_PTR(_r))->collection);
((db_mongodb_result_t*)RES_PTR(_r))->collection = NULL;
}
pkg_free(RES_PTR(_r));
}
db_free_result(_r);
return 0;
}
static void mapinfowindow_load_cities(gint nStateID)
{
db_resultset_t* pResultSet = NULL;
db_row_t aRow;
//
// Load up all cities for this state
//
gchar* pszSQL = g_strdup_printf("SELECT City.ID, City.Name FROM City WHERE StateID=%d ORDER BY Name ASC;", nStateID);
db_query(pszSQL, &pResultSet);
g_free(pszSQL);
g_return_if_fail(pResultSet != NULL);
// New menu
if(g_MapInfoWindow.pCityMenu) {
gtk_widget_destroy(GTK_WIDGET(g_MapInfoWindow.pCityMenu));
}
g_MapInfoWindow.pCityMenu = GTK_MENU(gtk_menu_new());
// Fill menu
while((aRow = db_fetch_row(pResultSet)) != NULL) {
gint nCityID = atoi(aRow[0]);
gchar* pszName = aRow[1];
// Add new menu item
GtkMenuItem* pNewMenuItem = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic(pszName));
g_signal_connect(G_OBJECT(pNewMenuItem), "activate", (GCallback)mapinfowindow_on_city_chosen, GINT_TO_POINTER(nCityID));
gtk_menu_shell_append(GTK_MENU_SHELL(g_MapInfoWindow.pCityMenu), GTK_WIDGET(pNewMenuItem));
}
db_free_result(pResultSet);
// Install new menu
gtk_widget_show_all(GTK_WIDGET(g_MapInfoWindow.pCityMenu));
gtk_menu_tool_button_set_menu(g_MapInfoWindow.pCityButton, GTK_WIDGET(g_MapInfoWindow.pCityMenu));
}
/*
* Insert a row into specified table
* _con: structure representing database connection
* _k: key names
* _v: values of the keys
* _n: number of key=value pairs
*/
int db_postgres_insert(const db_con_t* _h, const db_key_t* _k,
const db_val_t* _v, const int _n)
{
db_res_t* _r = NULL;
CON_RESET_CURR_PS(_h); /* no prepared statements support */
/* This needs to be reset before each call to db_do_insert.
This is only used by inserts, but as a side effect delete and updates
will set it to 1 without resetting it. */
submit_func_called = 0;
int tmp = db_do_insert(_h, _k, _v, _n, db_postgres_val2str,
db_postgres_submit_query);
/* For bulk queries the insert may not be submitted until enough rows are queued */
if (submit_func_called)
{
/* Query was submitted.
Result must be handled. */
if (db_postgres_store_result(_h, &_r) != 0)
LM_WARN("unexpected result returned\n");
}
if (_r)
db_free_result(_r);
if (CON_HAS_INSLIST(_h))
CON_RESET_INSLIST(_h);
return tmp;
}
/**
* \brief Gets a partial result set, fetch rows from a result
*
* Gets a partial result set, fetch a number of rows from a database result.
* This function initialize the given result structure on the first run, and
* fetches the nrows number of rows. On subsequenting runs, it uses the
* existing result and fetches more rows, until it reaches the end of the
* result set. Because of this the result needs to be null in the first
* invocation of the function. If the number of wanted rows is zero, the
* function returns anything with a result of zero.
* \param _h structure representing the database connection
* \param _r pointer to a structure representing the result
* \param nrows number of fetched rows
* \return zero on success, negative value on failure
*/
int erlang_srdb1_fetch_result(const db1_con_t* _h, db1_res_t** _r, const int nrows)
{
int rows, i, code;
LM_DBG("erlang_srdb1_fetch_result\n");
if (!_h || !_r || nrows < 0) {
LM_ERR("Invalid parameter value\n");
return -1;
}
/* exit if the fetch count is zero */
if (nrows == 0) {
db_free_result(*_r);
*_r = 0;
return 0;
}
if(*_r==0) {
/* Allocate a new result structure */
*_r = db_new_result();
if (*_r == 0) {
LM_ERR("no memory left\n");
return -2;
}
} else {
/* free old rows */
if(RES_ROWS(*_r)!=0)
db_free_rows(*_r);
RES_ROWS(*_r) = 0;
RES_ROW_N(*_r) = 0;
}
/* determine the number of rows remaining to be processed */
rows = RES_NUM_ROWS(*_r) - RES_LAST_ROW(*_r);
/* If there aren't any more rows left to process, exit */
if(rows<=0)
return 0;
/* if the fetch count is less than the remaining rows to process */
/* set the number of rows to process (during this call) equal to the fetch count */
if(nrows < rows)
rows = nrows;
RES_ROW_N(*_r) = rows;
LM_DBG("converting row %d of %d count %d\n", RES_LAST_ROW(*_r),
RES_NUM_ROWS(*_r), RES_ROW_N(*_r));
RES_ROWS(*_r) = (struct db_row*)pkg_malloc(sizeof(db_row_t) * rows);
if (!RES_ROWS(*_r)) {
LM_ERR("no memory left\n");
return -5;
}
/* update the total number of rows processed */
RES_LAST_ROW(*_r) += rows;
return 0;
}
/*
* Insert a row into specified table
* _con: structure representing database connection
* _k: key names
* _v: values of the keys
* _n: number of key=value pairs
*/
int db_postgres_insert(const db_con_t* _h, const db_key_t* _k,
const db_val_t* _v, const int _n)
{
db_res_t* _r = NULL;
CON_RESET_CURR_PS(_h); /* no prepared statements support */
int tmp = db_do_insert(_h, _k, _v, _n, db_postgres_val2str,
db_postgres_submit_query);
if (submit_func_called)
{
/* finish the async query,
* otherwise the next query will not complete */
/* only call this if the DB API has effectively called
* our submit_query function
*
* in case of insert queueing,
* it may postpone calling the insert func until
* enough rows have piled up */
if (db_postgres_store_result(_h, &_r) != 0)
LM_WARN("unexpected result returned\n");
submit_func_called = 0;
}
if (_r)
db_free_result(_r);
if (CON_HAS_INSLIST(_h))
CON_RESET_INSLIST(_h);
return tmp;
}
int db_postgres_free_result(db_con_t* _con, db_res_t* _r)
{
free_query(_con);
if (_r) db_free_result(_r);
_r = 0;
return 0;
}
int db_postgres_async_free_result(db_con_t *_h, db_res_t *_r, void *_priv)
{
struct pg_con *con = (struct pg_con *)_priv;
if (_r && db_free_result(_r) < 0) {
LM_ERR("error while freeing result structure\n");
}
PQclear(con->res);
con->res = NULL;
return 0;
}
/*!
* \brief Free the query and the result memory in the core
* \param _con database connection
* \param _r result set
* \return 0 on success, -1 on failure
*/
int db_postgres_free_result(db1_con_t* _con, db1_res_t* _r)
{
if ((!_con) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_free_result(_r) < 0) {
LM_ERR("unable to free result structure\n");
return -1;
}
db_postgres_free_query(_con);
return 0;
}
int resume_async_dbquery(int fd, struct sip_msg *msg, void *_param)
{
db_res_t *res = NULL;
query_async_param *param = (query_async_param *)_param;
int rc;
rc = param->dbf->async_raw_resume(param->hdl, fd, &res, param->db_param);
if (async_status == ASYNC_CONTINUE || async_status == ASYNC_CHANGE_FD) {
return rc;
}
if (rc != 0) {
LM_ERR("async query returned error\n");
pkg_free(param);
return -1;
}
if (!res || RES_ROW_N(res) <= 0 || RES_COL_N(res) <= 0) {
LM_DBG("query returned no results\n");
db_free_result(res);
pkg_free(param);
return -2;
}
if (db_query_avp_print_results(msg, res, param->output_avps) != 0) {
LM_ERR("failed to print results\n");
db_free_result(res);
pkg_free(param);
return -1;
}
async_status=ASYNC_DONE;
db_free_result(res);
pkg_free(param);
return 1;
}
/*
* Release a result set from memory
*/
int db_oracle_free_result(db1_con_t* _h, db1_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;
}
return 0;
}
/*!
* \brief Allocate new result set with private structure
* \return db1_res_t object on success, NULL on failure
*/
db1_res_t* db_mysql_new_result(void)
{
db1_res_t* obj;
obj = db_new_result();
if (!obj)
return NULL;
RES_PTR(obj) = pkg_malloc(sizeof(struct my_res));
if (!RES_PTR(obj)) {
db_free_result(obj);
return NULL;
}
return obj;
}
/**
* Release a result set from memory.
* \param _h handle to the database
* \param _r result set that should be freed
* \return zero on success, negative value on failure
*/
int db_mysql_free_result(db1_con_t* _h, db1_res_t* _r)
{
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_free_result(_r) < 0) {
LM_ERR("unable to free result structure\n");
return -1;
}
mysql_free_result(CON_RESULT(_h));
CON_RESULT(_h) = 0;
return 0;
}
/*!
* \brief Insert a row into specified table
* \param _h structure representing database connection
* \param _k key names
* \param _v values of the keys
* \param _n number of key=value pairs
* \return 0 on success, negative on failure
*/
int db_postgres_insert(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v,
const int _n)
{
db1_res_t* _r = NULL;
int tmp = db_do_insert(_h, _k, _v, _n, db_postgres_val2str, db_postgres_submit_query);
// finish the async query, otherwise the next query will not complete
if (db_postgres_store_result(_h, &_r) != 0)
LM_WARN("unexpected result returned");
if (_r)
db_free_result(_r);
return tmp;
}
/*!
* \brief Delete a row from the specified table
* \param _h structure representing database connection
* \param _k key names
* \param _o operators
* \param _v values of the keys that must match
* \param _n number of key=value pairs
* \return 0 on success, negative on failure
*/
int db_postgres_delete(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
const db_val_t* _v, const int _n)
{
db1_res_t* _r = NULL;
int tmp = db_do_delete(_h, _k, _o, _v, _n, db_postgres_val2str,
db_postgres_submit_query);
if (db_postgres_store_result(_h, &_r) != 0)
LM_WARN("unexpected result returned");
if (_r)
db_free_result(_r);
return tmp;
}
db1_res_t* db_mongodb_new_result(void)
{
db1_res_t* obj;
obj = db_new_result();
if (!obj)
return NULL;
RES_PTR(obj) = pkg_malloc(sizeof(db_mongodb_result_t));
if (!RES_PTR(obj)) {
db_free_result(obj);
return NULL;
}
memset(RES_PTR(obj), 0, sizeof(db_mongodb_result_t));
return obj;
}
/**
* Release a result set from memory.
* \param _h handle to the database
* \param _r result set that should be freed
* \return zero on success, negative value on failure
*/
int erlang_srdb1_free_result(db1_con_t* _h, db1_res_t* _r)
{
LM_DBG("erlang_srdb1_free_result\n");
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (db_free_result(_r) < 0) {
LM_ERR("unable to free result structure\n");
return -1;
}
// mysql_free_result(CON_RESULT(_h));
// CON_RESULT(_h) = 0;
return 0;
}
/**
* Release a result set from memory.
* \param _h handle to the database
* \param _r result set that should be freed
* \return zero on success, negative value on failure
*/
int db_mysql_free_result(const db1_con_t* _h, db1_res_t* _r)
{
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
mysql_free_result(RES_RESULT(_r));
RES_RESULT(_r) = 0;
pkg_free(RES_PTR(_r));
if (db_free_result(_r) < 0) {
LM_ERR("unable to free result structure\n");
return -1;
}
return 0;
}
/*
* Delete a row from the specified table
* _con: structure representing database connection
* _k: key names
* _o: operators
* _v: values of the keys that must match
* _n: number of key=value pairs
*/
int db_postgres_delete(const db_con_t* _h, const db_key_t* _k,
const db_op_t* _o, const db_val_t* _v, const int _n)
{
db_res_t* _r = NULL;
CON_RESET_CURR_PS(_h); /* no prepared statements support */
int tmp = db_do_delete(_h, _k, _o, _v, _n, db_postgres_val2str,
db_postgres_submit_query);
if (db_postgres_store_result(_h, &_r) != 0)
LM_WARN("unexpected result returned");
if (_r)
db_free_result(_r);
return tmp;
}
/*
* Release a result set from memory
*/
int db_unixodbc_free_result(db1_con_t* _h, db1_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) = 0;
return 0;
}
/*
* Retrieve result set
*/
static int db_unixodbc_store_result(const db_con_t* _h, db_res_t** _r)
{
SQLSMALLINT cols;
SQLLEN aff_cols;
if ((!_h) || (!_r))
{
LM_ERR("invalid parameter value\n");
return -1;
}
*_r = db_new_result();
if (*_r == 0)
{
LM_ERR("no memory left\n");
return -2;
}
SQLNumResultCols(CON_RESULT(_h), &cols);
if (!cols) {
SQLRowCount(CON_RESULT(_h), &aff_cols);
if (aff_cols > 0) {
(*_r)->col.n = 0;
(*_r)->n = 0;
return 0;
} else {
LM_ERR(" invalid SQL query\n");
db_free_result(*_r);
*_r = 0;
return -3;
}
}
if (db_unixodbc_convert_result(_h, *_r) < 0)
{
LM_ERR("failed to convert result\n");
pkg_free(*_r);
*_r = 0;
return -4;
}
return 0;
}
/*!
* Update some rows in the specified table
* \param _h structure representing database connection
* \param _k key names
* \param _o operators
* \param _v values of the keys that must match
* \param _uk updated columns
* \param _uv updated values of the columns
* \param _n number of key=value pairs
* \param _un number of columns to update
* \return 0 on success, negative on failure
*/
int db_postgres_update(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
const db_val_t* _v, const db_key_t* _uk, const db_val_t* _uv, const int _n,
const int _un)
{
db1_res_t* _r = NULL;
int ret = db_do_update(_h, _k, _o, _v, _uk, _uv, _n, _un, db_postgres_val2str,
db_postgres_submit_query);
int tmp = db_postgres_store_result(_h, &_r);
if (tmp < 0) {
LM_WARN("unexpected result returned");
ret = tmp;
}
if (_r)
db_free_result(_r);
return ret;
}
/*
* Release a result set from memory
*/
int db_oracle_free_result(db_con_t* _h, db_res_t* _r)
{
ub4 i;
if (!_h || !_r) {
LM_ERR("invalid parameter value\n");
return -1;
}
if (RES_NAMES(_r))
for (i=0; i < RES_COL_N(_r); ++i)
if (RES_NAMES(_r)[i]->s)
pkg_free(RES_NAMES(_r)[i]->s);
if (db_free_result(_r) < 0)
{
LM_ERR("failed to free result structure\n");
return -1;
}
return 0;
}
/*
* Free all memory allocated by get_result
*/
int dbt_free_result(db1_con_t* _h, db1_res_t* _r)
{
if ((!_h) || (!_r))
{
LM_ERR("invalid parameter value\n");
return -1;
}
if(dbt_result_free((dbt_result_p)_r->ptr) < 0)
{
LM_ERR("unable to free internal structure\n");
}
if(db_free_result(_r) < 0)
{
LM_ERR("unable to free result structure\n");
return -1;
}
return 0;
}
/*
* Release a result set from memory
*/
int perlvdb_db_free_result(db_con_t* _h, db_res_t* _r) {
int i,j;
SV* temp;
/* free result set
* use the order of allocation
* first free values
*/
if(_r){
/* for each row */
for(i=0; i < RES_ROW_N(_r); i++){
/* for each column in row i */
for(j=0; j < RES_ROWS(_r)[i].n; j++){
switch ( (RES_ROWS(_r)[i].values)[j].type ) { /* the type of a value j in row i */
case DB_STRING:
case DB_STR:
pkg_free((RES_ROWS(_r)[i].values)[j].val.str_val.s);
break;
case DB_BLOB:
pkg_free((RES_ROWS(_r)[i].values)[j].val.blob_val.s) ;
break;
case DB_INT:
case DB_BIGINT:
case DB_DOUBLE:
case DB_BITMAP:
case DB_DATETIME:
break;
}
} /* for each column in row i*/
} /* for each row */
for(i=0; i< RES_COL_N(_r); i++){
pkg_free(RES_NAMES(_r)[i]->s);
}
db_free_result(_r);
}
return 0;
}
/*
*
* pg_fetch_result: Gets a partial result set.
*
*/
int db_postgres_fetch_result(const db_con_t* _con, db_res_t** _res, const int nrows)
{
int rows;
ExecStatusType pqresult;
if (!_con || !_res || nrows < 0) {
LM_ERR("invalid parameter value\n");
return -1;
}
/* exit if the fetch count is zero */
if (nrows == 0) {
if (*_res)
db_free_result(*_res);
*_res = 0;
return 0;
}
if (*_res == NULL) {
/* Allocate a new result structure */
*_res = db_new_result();
pqresult = PQresultStatus(CON_RESULT(_con));
LM_DBG("%p PQresultStatus(%s) PQgetResult(%p)\n", _con,
PQresStatus(pqresult), CON_RESULT(_con));
switch(pqresult) {
case PGRES_COMMAND_OK:
/* Successful completion of a command returning no data
* (such as INSERT or UPDATE). */
return 0;
case PGRES_TUPLES_OK:
/* Successful completion of a command returning data
* (such as a SELECT or SHOW). */
if (db_postgres_get_columns(_con, *_res) < 0) {
LM_ERR("failed to get column names\n");
return -2;
}
break;
case PGRES_FATAL_ERROR:
LM_ERR("%p - invalid query, execution aborted\n", _con);
LM_ERR("%p - PQresultStatus(%s)\n",_con,PQresStatus(pqresult));
LM_ERR("%p: %s\n",_con,PQresultErrorMessage(CON_RESULT(_con)));
if (*_res)
db_free_result(*_res);
*_res = 0;
return -3;
case PGRES_EMPTY_QUERY:
/* notice or warning */
case PGRES_NONFATAL_ERROR:
/* status for COPY command, not used */
case PGRES_COPY_OUT:
case PGRES_COPY_IN:
/* unexpected response */
case PGRES_BAD_RESPONSE:
default:
LM_ERR("%p - probable invalid query\n", _con);
LM_ERR("%p - PQresultStatus(%s)\n",_con,PQresStatus(pqresult));
LM_ERR("%p: %s\n",_con,PQresultErrorMessage(CON_RESULT(_con)));
if (*_res)
db_free_result(*_res);
*_res = 0;
return -4;
}
} else {
if(RES_ROWS(*_res) != NULL) {
db_free_rows(*_res);
}
RES_ROWS(*_res) = 0;
RES_ROW_N(*_res) = 0;
}
/* Get the number of rows (tuples) in the query result. */
RES_NUM_ROWS(*_res) = PQntuples(CON_RESULT(_con));
/* determine the number of rows remaining to be processed */
rows = RES_NUM_ROWS(*_res) - RES_LAST_ROW(*_res);
/* If there aren't any more rows left to process, exit */
if (rows <= 0)
return 0;
/* if the fetch count is less than the remaining rows to process */
/* set the number of rows to process (during this call) equal to
* the fetch count */
if (nrows < rows)
rows = nrows;
RES_ROW_N(*_res) = rows;
LM_DBG("converting row %d of %d count %d\n", RES_LAST_ROW(*_res),
RES_NUM_ROWS(*_res), RES_ROW_N(*_res));
if (db_postgres_convert_rows(_con, *_res) < 0) {
LM_ERR("failed to convert rows\n");
if (*_res)
db_free_result(*_res);
*_res = 0;
return -3;
}
/* update the total number of rows processed */
RES_LAST_ROW(*_res) += rows;
return 0;
}
/**
* Gets a partial result set.
* \param _h structure representing the database connection
* \param _r pointer to a structure representing the result
* \param nrows number of fetched rows
* \return zero on success, negative value on failure
*/
int db_sqlite_fetch_result(const db_con_t* _h, db_res_t** _r, const int nrows)
{
int ret;
int rows, i;
sqlite3_stmt* stmt;
if (!_h || !_r || nrows < 0) {
LM_ERR("Invalid parameter value\n");
return -1;
}
/* exit if the fetch count is zero */
if (nrows == 0) {
db_free_result(*_r);
*_r = 0;
return 0;
}
if(*_r==0) {
/* Allocate a new result structure */
*_r = db_new_result();
if (*_r == 0) {
LM_ERR("no memory left\n");
return -2;
}
if (db_sqlite_get_columns(_h, *_r) < 0) {
LM_ERR("error while getting column names\n");
return -4;
}
RES_NUM_ROWS(*_r) = CON_PS_ROWS(_h);
if (!RES_NUM_ROWS(*_r)) {
LM_DBG("no rows returned from the query\n");
RES_ROWS(*_r) = 0;
return 0;
}
} else {
/* free old rows */
if(RES_ROWS(*_r)!=0)
db_free_rows(*_r);
RES_ROWS(*_r) = 0;
RES_ROW_N(*_r) = 0;
}
/* determine the number of rows remaining to be processed */
rows = RES_NUM_ROWS(*_r) - RES_LAST_ROW(*_r);
/* If there aren't any more rows left to process, exit */
if(rows<=0)
return 0;
/* if the fetch count is less than the remaining rows to process */
/* set the number of rows to process (during this call) equal
to the fetch count */
if(nrows < rows)
rows = nrows;
RES_ROW_N(*_r) = rows;
if (db_sqlite_allocate_rows(*_r, rows)!=0) {
LM_ERR("no memory left\n");
return -5;
}
i = 0;
ret=-1;
stmt = CON_SQLITE_PS(_h);
while (ret != SQLITE_DONE) {
if (i == nrows) {
RES_LAST_ROW(*_r) = i - 1;
break;
}
ret = sqlite3_step(stmt);
if (ret == SQLITE_DONE) {
RES_ROW_N(*_r) = RES_LAST_ROW(*_r) = RES_NUM_ROWS(*_r) = i;
sqlite3_finalize(CON_SQLITE_PS(_h));
CON_SQLITE_PS(_h) = NULL;
break;
}
if (i >= RES_ROW_N(*_r) && i < nrows) {
db_sqlite_realloc_rows(*_r, RES_ROW_N(*_r) + db_sqlite_alloc_limit);
RES_ROW_N(*_r) += db_sqlite_alloc_limit;
}
if ((ret=db_sqlite_convert_row(_h, *_r, &(RES_ROWS(*_r)[i]))) < 0) {
LM_ERR("error while converting row #%d\n", i);
RES_ROW_N(*_r) = i;
db_free_rows(*_r);
return -4;
}
i++;
}
return 0;
}
/**
* \brief Gets a partial result set, fetch rows from a result
*
* Gets a partial result set, fetch a number of rows from a database result.
* This function initialize the given result structure on the first run, and
* fetches the nrows number of rows. On subsequenting runs, it uses the
* existing result and fetches more rows, until it reaches the end of the
* result set. Because of this the result needs to be null in the first
* invocation of the function. If the number of wanted rows is zero, the
* function returns anything with a result of zero.
* \param _h structure representing the database connection
* \param _r pointer to a structure representing the result
* \param nrows number of fetched rows
* \return zero on success, negative value on failure
*/
int db_mysql_fetch_result(const db1_con_t* _h, db1_res_t** _r, const int nrows)
{
int rows, i, code;
if (!_h || !_r || nrows < 0) {
LM_ERR("Invalid parameter value\n");
return -1;
}
/* exit if the fetch count is zero */
if (nrows == 0) {
db_free_result(*_r);
*_r = 0;
return 0;
}
if(*_r==0) {
/* Allocate a new result structure */
*_r = db_new_result();
if (*_r == 0) {
LM_ERR("no memory left\n");
return -2;
}
CON_RESULT(_h) = mysql_store_result(CON_CONNECTION(_h));
if (!CON_RESULT(_h)) {
if (mysql_field_count(CON_CONNECTION(_h)) == 0) {
(*_r)->col.n = 0;
(*_r)->n = 0;
return 0;
} else {
LM_ERR("driver error: %s\n", mysql_error(CON_CONNECTION(_h)));
code = mysql_errno(CON_CONNECTION(_h));
if (code == CR_SERVER_GONE_ERROR || code == CR_SERVER_LOST) {
counter_inc(mysql_cnts_h.driver_err);
}
db_free_result(*_r);
*_r = 0;
return -3;
}
}
if (db_mysql_get_columns(_h, *_r) < 0) {
LM_ERR("error while getting column names\n");
return -4;
}
RES_NUM_ROWS(*_r) = mysql_num_rows(CON_RESULT(_h));
if (!RES_NUM_ROWS(*_r)) {
LM_DBG("no rows returned from the query\n");
RES_ROWS(*_r) = 0;
return 0;
}
} else {
/* free old rows */
if(RES_ROWS(*_r)!=0)
db_free_rows(*_r);
RES_ROWS(*_r) = 0;
RES_ROW_N(*_r) = 0;
}
/* determine the number of rows remaining to be processed */
rows = RES_NUM_ROWS(*_r) - RES_LAST_ROW(*_r);
/* If there aren't any more rows left to process, exit */
if(rows<=0)
return 0;
/* if the fetch count is less than the remaining rows to process */
/* set the number of rows to process (during this call) equal to the fetch count */
if(nrows < rows)
rows = nrows;
RES_ROW_N(*_r) = rows;
LM_DBG("converting row %d of %d count %d\n", RES_LAST_ROW(*_r),
RES_NUM_ROWS(*_r), RES_ROW_N(*_r));
RES_ROWS(*_r) = (struct db_row*)pkg_malloc(sizeof(db_row_t) * rows);
if (!RES_ROWS(*_r)) {
LM_ERR("no memory left\n");
return -5;
}
for(i = 0; i < rows; i++) {
CON_ROW(_h) = mysql_fetch_row(CON_RESULT(_h));
if (!CON_ROW(_h)) {
LM_ERR("driver error: %s\n", mysql_error(CON_CONNECTION(_h)));
RES_ROW_N(*_r) = i;
db_free_rows(*_r);
return -6;
}
if (db_mysql_convert_row(_h, *_r, &(RES_ROWS(*_r)[i])) < 0) {
LM_ERR("error while converting row #%d\n", i);
RES_ROW_N(*_r) = i;
db_free_rows(*_r);
return -7;
}
}
/* update the total number of rows processed */
RES_LAST_ROW(*_r) += rows;
return 0;
}
/**
* Retrieve a result set
* \param _h handle to the database
* \param _r result set that should be retrieved
* \return zero on success, negative value on failure
*/
static int db_mysql_store_result(const db1_con_t* _h, db1_res_t** _r)
{
int code;
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter value\n");
return -1;
}
*_r = db_new_result();
if (*_r == 0) {
LM_ERR("no memory left\n");
return -2;
}
CON_RESULT(_h) = mysql_store_result(CON_CONNECTION(_h));
if (!CON_RESULT(_h)) {
if (mysql_field_count(CON_CONNECTION(_h)) == 0) {
(*_r)->col.n = 0;
(*_r)->n = 0;
goto done;
} else {
LM_ERR("driver error: %s\n", mysql_error(CON_CONNECTION(_h)));
code = mysql_errno(CON_CONNECTION(_h));
if (code == CR_SERVER_GONE_ERROR || code == CR_SERVER_LOST) {
counter_inc(mysql_cnts_h.driver_err);
}
db_free_result(*_r);
*_r = 0;
return -3;
}
}
if (db_mysql_convert_result(_h, *_r) < 0) {
LM_ERR("error while converting result\n");
LM_DBG("freeing result set at %p\n", _r);
pkg_free(*_r);
*_r = 0;
/* all mem on openser API side is already freed by
* db_mysql_convert_result in case of error, but we also need
* to free the mem from the mysql lib side */
mysql_free_result(CON_RESULT(_h));
#if (MYSQL_VERSION_ID >= 40100)
while( mysql_next_result( CON_CONNECTION(_h) ) > 0 ) {
MYSQL_RES *res = mysql_store_result( CON_CONNECTION(_h) );
mysql_free_result(res);
}
#endif
CON_RESULT(_h) = 0;
return -4;
}
done:
#if (MYSQL_VERSION_ID >= 40100)
while( mysql_next_result( CON_CONNECTION(_h) ) > 0 ) {
MYSQL_RES *res = mysql_store_result( CON_CONNECTION(_h) );
mysql_free_result(res);
}
#endif
return 0;
}
int db_postgres_store_result(const db_con_t* _con, db_res_t** _r)
{
ExecStatusType pqresult;
int rc = 0;
*_r = db_new_result();
if (*_r==NULL) {
LM_ERR("failed to init new result\n");
rc = -1;
goto done;
}
pqresult = PQresultStatus(CON_RESULT(_con));
LM_DBG("%p PQresultStatus(%s) PQgetResult(%p)\n", _con,
PQresStatus(pqresult), CON_RESULT(_con));
switch(pqresult) {
case PGRES_COMMAND_OK:
/* Successful completion of a command returning no data
* (such as INSERT or UPDATE). */
rc = 0;
break;
case PGRES_TUPLES_OK:
/* Successful completion of a command returning data
* (such as a SELECT or SHOW). */
if (db_postgres_convert_result(_con, *_r) < 0) {
LM_ERR("%p Error returned from convert_result()\n", _con);
db_free_result(*_r);
*_r = 0;
rc = -4;
break;
}
rc = 0;
break;
/* query failed */
case PGRES_FATAL_ERROR:
LM_ERR("%p - invalid query, execution aborted\n", _con);
LM_ERR("%p: %s\n", _con, PQresStatus(pqresult));
LM_ERR("%p: %s\n", _con, PQresultErrorMessage(CON_RESULT(_con)));
db_free_result(*_r);
*_r = 0;
rc = -3;
break;
case PGRES_EMPTY_QUERY:
/* notice or warning */
case PGRES_NONFATAL_ERROR:
/* status for COPY command, not used */
case PGRES_COPY_OUT:
case PGRES_COPY_IN:
/* unexpected response */
case PGRES_BAD_RESPONSE:
default:
LM_ERR("%p Probable invalid query\n", _con);
LM_ERR("%p: %s\n", _con, PQresStatus(pqresult));
LM_ERR("%p: %s\n", _con, PQresultErrorMessage(CON_RESULT(_con)));
db_free_result(*_r);
*_r = 0;
rc = -4;
break;
}
done:
free_query(_con);
return (rc);
}
/*
* Query table for specified rows
* _h: structure representing database connection
* _k: key names
* _op: operators
* _v: values of the keys that must match
* _c: column names to return
* _n: number of key=values pairs to compare
* _nc: number of columns to return
* _o: order by the specified column
*/
int db_cassa_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op,
const db_val_t* _v, const db_key_t* _c, int _n, int _nc,
const db_key_t _o, db1_res_t** _r)
{
db1_res_t* db_res = 0;
int rows_no;
ColumnVecPtr cassa_result;
dbcassa_table_p tbc;
int seckey_len;
if (!_h || !CON_TABLE(_h) || !_r) {
LM_ERR("invalid parameter value\n");
return -1;
}
LM_DBG("query table=%s\n", _h->table->s);
/** Construct and send the query to Cassandra Cluster **/
cassa_result = cassa_translate_query(_h, _k, _v, _c, _n, _nc, &rows_no);
if(cassa_result.get() == NULL) {
LM_ERR("Failed to query Cassandra cluster\n");
return -1;
}
/* compare the number of queried cols with the key cols*/
// if(no_kc + no_sec_kc < _n) { /* TODO */
/* filter manually for the rest of the values */
// }
db_res = db_new_result();
if (!db_res) {
LM_ERR("no memory left\n");
goto error;
}
RES_COL_N(db_res)= _nc;
if(!db_allocate_columns(db_res, _nc) < 0) {
LM_ERR("no more memory\n");
goto error;
}
tbc = dbcassa_db_get_table(&CON_CASSA(_h)->db_name, CON_TABLE(_h));
if(!tbc) {
LM_ERR("table %.*s does not exist!\n", CON_TABLE(_h)->len, CON_TABLE(_h)->s);
return -1;
}
/** Convert the result from Cassandra **/
/* fill in the columns name and type */
for(int col = 0; col < _nc; col++) {
RES_NAMES(db_res)[col] = (str*)pkg_malloc(sizeof(str));
if (! RES_NAMES(db_res)[col]) {
LM_ERR("no private memory left\n");
dbcassa_lock_release(tbc);
RES_COL_N(db_res) = col;
db_free_columns(db_res);
goto error;
}
*RES_NAMES(db_res)[col] = *_c[col];
/* search the column in table schema to get the type */
dbcassa_column_p colp = cassa_search_col(tbc, _c[col]);
if(!colp) {
LM_ERR("No column with name [%.*s] found\n", _c[col]->len, _c[col]->s);
dbcassa_lock_release(tbc);
RES_COL_N(db_res) = col;
db_free_columns(db_res);
goto error;
}
RES_TYPES(db_res)[col] = colp->type;
LM_DBG("RES_NAMES(%p)[%d]=[%.*s]\n", RES_NAMES(db_res)[col], col,
RES_NAMES(db_res)[col]->len, RES_NAMES(db_res)[col]->s);
}
/* TODO if all columns asked - take from table schema */
seckey_len = tbc->seckey_len;
dbcassa_lock_release(tbc);
if(!cassa_result->size()) {
LM_DBG("The query returned no result\n");
RES_ROW_N(db_res) = 0;
goto done;
}
/* Initialize the row_slices vector for the case with one column and no secondary key */
if(rows_no == 1) {
row_slices[0][0]= cassa_result->size();
row_slices[0][1]= 0;
if(seckey_len) { /* if the table has a secondary key defined */
/* pass through the result once to see how many rows there are */
rows_no = cassa_result_separate_rows(*cassa_result);
if(rows_no < 0) {
LM_ERR("Wrong formated column names\n");
goto error;
}
}
}
RES_ROW_N(db_res) = rows_no;
if (db_allocate_rows(db_res) < 0) {
LM_ERR("could not allocate rows");
goto error;
}
for(int ri=0; ri < rows_no; ri++) {
if (db_allocate_row(db_res, &(RES_ROWS(db_res)[ri])) != 0) {
LM_ERR("could not allocate row");
goto error;
}
/* complete the row with the columns */
for(int col = 0; col< _nc; col++) {
RES_ROWS(db_res)[ri].values[col].type = RES_TYPES(db_res)[col];
cassa_convert_result(_c[col], *cassa_result, (ri>0?row_slices[ri-1][0]:0), row_slices[ri][0],
row_slices[ri][1], &RES_ROWS(db_res)[ri].values[col]);
}
}
done:
*_r = db_res;
LM_DBG("Exited with success\n");
return 0;
error:
if(db_res)
db_free_result(db_res);
return -1;
}
