pq.c File Reference

helper functions for libpq (PostGres) interactions More...

#include "platform.h"
#include "gnunet_pq_lib.h"
#include "pq.h"

Include dependency graph for pq.c:

Go to the source code of this file.

Functions
PGresult *	GNUNET_PQ_exec_prepared (struct GNUNET_PQ_Context *db, const char *name, const struct GNUNET_PQ_QueryParam *params)
	Execute a prepared statement. More...
void	GNUNET_PQ_cleanup_query_params_closures (const struct GNUNET_PQ_QueryParam *params)
	Must be called to cleanup memory from closures after the query parameters have been used as much as needed. More...
void	GNUNET_PQ_cleanup_result (struct GNUNET_PQ_ResultSpec *rs)
	Free all memory that was allocated in rs during GNUNET_PQ_extract_result(). More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_extract_result (PGresult *result, struct GNUNET_PQ_ResultSpec *rs, int row)
	Extract results from a query result according to the given specification. More...

Detailed Description

helper functions for libpq (PostGres) interactions

Author

Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Florian Dold

Christian Grothoff

Definition in file pq.c.

Function Documentation

GNUNET_PQ_exec_prepared()

PGresult * GNUNET_PQ_exec_prepared	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		const struct GNUNET_PQ_QueryParam *	params
	)

Execute a prepared statement.

Parameters

db	database context
name	name of the prepared statement
params	parameters to the statement

Returns

postgres result

Deprecated:

(should become an internal API)

Definition at line 33 of file pq.c.

{
  unsigned int len;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Running prepared statement `%s' on %p\n",
              name,
              db);
  /* count the number of parameters */
  len = 0;
  for (unsigned int i = 0; 0 != params[i].num_params; i++)
    len += params[i].num_params;
 
  /* new scope to allow stack allocation without alloca */
  {
    /* Scratch buffer for temporary storage */
    void *scratch[GNUNET_NZL (len)];
    /* Parameter array we are building for the query */
    void *param_values[GNUNET_NZL (len)];
    int param_lengths[GNUNET_NZL (len)];
    int param_formats[GNUNET_NZL (len)];
    unsigned int off;
    /* How many entries in the scratch buffer are in use? */
    unsigned int soff;
    PGresult *res;
    int ret;
    ConnStatusType status;
 
    off = 0;
    soff = 0;
    for (unsigned int i = 0; 0 != params[i].num_params; i++)
    {
      const struct GNUNET_PQ_QueryParam *x = &params[i];
 
      ret = x->conv (x->conv_cls,
                     x->data,
                     x->size,
                     &param_values[off],
                     &param_lengths[off],
                     &param_formats[off],
                     x->num_params,
                     &scratch[soff],
                     len - soff);
      if (ret < 0)
      {
        for (off = 0; off < soff; off++)
          GNUNET_free (scratch[off]);
        return NULL;
      }
      soff += ret;
      off += x->num_params;
    }
    GNUNET_assert (off == len);
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "pq",
                     "Executing prepared SQL statement `%s'\n",
                     name);
    res = PQexecPrepared (db->conn,
                          name,
                          len,
                          (const char **) param_values,
                          param_lengths,
                          param_formats,
                          1);
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "pq",
                     "Execution of prepared SQL statement `%s' finished (%s)\n",
                     name,
                     PQresStatus (PQresultStatus (res)));
    if ( (PGRES_COMMAND_OK != PQresultStatus (res)) &&
         (CONNECTION_OK != (status = PQstatus (db->conn))) )
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                       "pq",
                       "Database disconnected on SQL statement `%s' (reconnecting)\n",
                       name);
      GNUNET_PQ_reconnect (db);
      res = NULL;
    }
 
    for (off = 0; off < soff; off++)
      GNUNET_free (scratch[off]);
    return res;
  }
}

References GNUNET_PQ_QueryParam::conv, GNUNET_PQ_QueryParam::conv_cls, GNUNET_PQ_QueryParam::data, db, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_log_from, GNUNET_NZL, GNUNET_PQ_reconnect(), name, GNUNET_PQ_QueryParam::num_params, res, ret, GNUNET_PQ_QueryParam::size, and status.

Referenced by GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_eval_prepared_non_select(), and GNUNET_PQ_eval_prepared_singleton_select().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_cleanup_query_params_closures()

void GNUNET_PQ_cleanup_query_params_closures

(

const struct GNUNET_PQ_QueryParam *

params

)

Must be called to cleanup memory from closures after the query parameters have been used as much as needed.

Parameters

params

Array of GNUNET_PQ_QueryParam which must terminate with a GNUNET_PQ_query_param_end

Definition at line 123 of file pq.c.

{
  for (unsigned int i = 0; 0 != params[i].num_params; i++)
  {
    const struct GNUNET_PQ_QueryParam *x = &params[i];
 
    if ((NULL != x->conv_cls) &&
        (NULL != x->conv_cls_cleanup))
      x->conv_cls_cleanup (x->conv_cls);
  }
 
}

References GNUNET_PQ_QueryParam::conv_cls, GNUNET_PQ_QueryParam::conv_cls_cleanup, and GNUNET_PQ_QueryParam::num_params.

GNUNET_PQ_cleanup_result()

void GNUNET_PQ_cleanup_result

(

struct GNUNET_PQ_ResultSpec *

rs

)

Free all memory that was allocated in rs during GNUNET_PQ_extract_result().

Parameters

rs	reult specification to clean up

Definition at line 139 of file pq.c.

{
  for (unsigned int i = 0; NULL != rs[i].conv; i++)
    if (NULL != rs[i].cleaner)
      rs[i].cleaner (rs[i].cls,
                     rs[i].dst);
}

References GNUNET_PQ_ResultSpec::cleaner, and GNUNET_PQ_ResultSpec::conv.

Referenced by check_patch_applied(), extract_result_cb(), handle_results(), namecache_postgres_lookup_block(), parse_result_call_iterator(), postgres_plugin_del(), process_keys(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_extract_result()

enum GNUNET_GenericReturnValue GNUNET_PQ_extract_result	(	PGresult *	result,
		struct GNUNET_PQ_ResultSpec *	rs,
		int	row
	)

Extract results from a query result according to the given specification.

Parameters

	result	result to process
[in,out]	rs	result specification to extract for
	row	row from the result to extract

Returns

GNUNET_YES if all results could be extracted GNUNET_SYSERR if a result was invalid (non-existing field)

Definition at line 149 of file pq.c.

{
  unsigned int i;
 
  if (NULL == result)
    return GNUNET_SYSERR;
  for (i = 0; NULL != rs[i].conv; i++)
  {
    struct GNUNET_PQ_ResultSpec *spec;
    enum GNUNET_GenericReturnValue ret;
 
    spec = &rs[i];
    ret = spec->conv (spec->cls,
                      result,
                      row,
                      spec->fname,
                      &spec->dst_size,
                      spec->dst);
    switch (ret)
    {
    case GNUNET_OK:
      /* canonical case, continue below */
      if (NULL != spec->is_null)
        *spec->is_null = false;
      break;
    case GNUNET_NO:
      if (spec->is_nullable)
      {
        if (NULL != spec->is_null)
          *spec->is_null = true;
        continue;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "NULL field encountered for `%s' where non-NULL was required\n",
                  spec->fname);
      goto cleanup;
    case GNUNET_SYSERR:
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to extract field `%s'\n",
                  spec->fname);
      GNUNET_break (0);
      goto cleanup;
    }
    if (NULL != spec->result_size)
      *spec->result_size = spec->dst_size;
  }
  return GNUNET_OK;
cleanup:
  for (unsigned int j = 0; j < i; j++)
    if (NULL != rs[j].cleaner)
      rs[j].cleaner (rs[j].cls,
                     rs[j].dst);
  return GNUNET_SYSERR;
}

References GNUNET_PQ_ResultSpec::cleaner, cleanup(), GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::conv, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_PQ_ResultSpec::is_null, GNUNET_PQ_ResultSpec::is_nullable, result, GNUNET_PQ_ResultSpec::result_size, and ret.

Referenced by extract_result_cb(), GNUNET_PQ_eval_prepared_singleton_select(), handle_results(), parse_result_call_iterator(), process_keys(), and process_result().

Here is the call graph for this function:

Here is the caller graph for this function: