pq_eval.c File Reference

functions to execute SQL statements with arguments and/or results (PostGres) More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_pq_lib.h"

Include dependency graph for pq_eval.c:

Go to the source code of this file.

Macros
#define	PQ_DIAG_SQLSTATE_DEADLOCK   "40P01"
	Error code returned by Postgres for deadlock. More...
#define	PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION   "23505"
	Error code returned by Postgres for uniqueness violation. More...
#define	PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE   "40001"
	Error code returned by Postgres on serialization failure. More...

Functions
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_result (PGconn *connection, const char *statement_name, PGresult *result)
	Check the result's error code to see what happened. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_non_select (PGconn *connection, const char *statement_name, const struct GNUNET_PQ_QueryParam *params)
	Execute a named prepared statement that is NOT a SELECT statement in connnection using the given params. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_multi_select (PGconn *connection, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, GNUNET_PQ_PostgresResultHandler rh, void *rh_cls)
	Execute a named prepared statement that is a SELECT statement which may return multiple results in connection using the given params. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_singleton_select (PGconn *connection, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, struct GNUNET_PQ_ResultSpec *rs)
	Execute a named prepared statement that is a SELECT statement which must return a single result in connection using the given params. More...

Detailed Description

functions to execute SQL statements with arguments and/or results (PostGres)

Author

Christian Grothoff

Definition in file pq_eval.c.

Macro Definition Documentation

PQ_DIAG_SQLSTATE_DEADLOCK

#define PQ_DIAG_SQLSTATE_DEADLOCK   "40P01"

Error code returned by Postgres for deadlock.

Definition at line 33 of file pq_eval.c.

Referenced by GNUNET_PQ_eval_result().

PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION

#define PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION   "23505"

Error code returned by Postgres for uniqueness violation.

Definition at line 38 of file pq_eval.c.

Referenced by GNUNET_PQ_eval_result().

PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE

#define PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE   "40001"

Error code returned by Postgres on serialization failure.

Definition at line 43 of file pq_eval.c.

Referenced by GNUNET_PQ_eval_result().

Function Documentation

GNUNET_PQ_eval_result()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_result	(	PGconn *	connection,
		const char *	statement_name,
		PGresult *	result
	)

Check the result's error code to see what happened.

Also logs errors.

Parameters

connection	connection to execute the statement in
statement_name	name of the statement that created result
result	result to check

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus. Never returns positive values as this function does not look at the result set.

Deprecated:

(low level, let's see if we can do with just the high-level functions)

Definition at line 60 of file pq_eval.c.

References GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_DB_STATUS_SOFT_ERROR, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log_from, PQ_DIAG_SQLSTATE_DEADLOCK, PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE, and PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION.

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

{
  ExecStatusType est;

  est = PQresultStatus(result);
  if ((PGRES_COMMAND_OK != est) &&
      (PGRES_TUPLES_OK != est))
    {
      const char *sqlstate;

      sqlstate = PQresultErrorField(result,
                                    PG_DIAG_SQLSTATE);
      if (NULL == sqlstate)
        {
          /* very unexpected... */
          GNUNET_break(0);
          return GNUNET_DB_STATUS_HARD_ERROR;
        }
      if ((0 == strcmp(sqlstate,
                       PQ_DIAG_SQLSTATE_DEADLOCK)) ||
          (0 == strcmp(sqlstate,
                       PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)))
        {
          /* These two can be retried and have a fair chance of working
             the next time */
          GNUNET_log_from(GNUNET_ERROR_TYPE_INFO,
                          "pq",
                          "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
                          statement_name,
                          PQresultErrorField(result,
                                             PG_DIAG_MESSAGE_PRIMARY),
                          PQresultErrorField(result,
                                             PG_DIAG_MESSAGE_DETAIL),
                          PQresultErrorMessage(result),
                          PQresStatus(PQresultStatus(result)),
                          PQerrorMessage(connection));
          return GNUNET_DB_STATUS_SOFT_ERROR;
        }
      if (0 == strcmp(sqlstate,
                      PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION))
        {
          /* Likely no need to retry, INSERT of "same" data. */
          GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
                          "pq",
                          "Query `%s' failed with unique violation: %s/%s/%s/%s/%s\n",
                          statement_name,
                          PQresultErrorField(result,
                                             PG_DIAG_MESSAGE_PRIMARY),
                          PQresultErrorField(result,
                                             PG_DIAG_MESSAGE_DETAIL),
                          PQresultErrorMessage(result),
                          PQresStatus(PQresultStatus(result)),
                          PQerrorMessage(connection));
          return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
        }
      GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR,
                      "pq",
                      "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
                      statement_name,
                      PQresultErrorField(result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                      PQresultErrorField(result,
                                         PG_DIAG_MESSAGE_DETAIL),
                      PQresultErrorMessage(result),
                      PQresStatus(PQresultStatus(result)),
                      PQerrorMessage(connection));
      return GNUNET_DB_STATUS_HARD_ERROR;
    }
  return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
}

Here is the caller graph for this function:

GNUNET_PQ_eval_prepared_non_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_non_select	(	PGconn *	connection,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params
	)

Execute a named prepared statement that is NOT a SELECT statement in connnection using the given params.

Returns the resulting session state.

Parameters

connection	connection to execute the statement in
statement_name	name of the statement
params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus. If the statement was a DELETE or UPDATE statement, the number of affected rows is returned.; if the statment was an INSERT statement, and no row was added due to a UNIQUE violation, we return zero; if INSERT was successful, we return one.

Definition at line 151 of file pq_eval.c.

References GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_PQ_eval_result(), GNUNET_PQ_exec_prepared(), and result.

Referenced by delete_old_block(), namecache_postgres_cache_block(), namecache_postgres_expire_blocks(), namestore_postgres_store_records(), postgres_plugin_del(), postgres_plugin_put(), postgres_plugin_remove_key(), process_result(), and repl_proc().

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;

  result = GNUNET_PQ_exec_prepared(connection,
                                   statement_name,
                                   params);
  qs = GNUNET_PQ_eval_result(connection,
                             statement_name,
                             result);
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs)
    {
      const char *tuples;

      /* What an awful API, this function really does return a string */
      tuples = PQcmdTuples(result);
      if (NULL != tuples)
        qs = strtol(tuples, NULL, 10);
    }
  PQclear(result);
  return qs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_eval_prepared_multi_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_multi_select	(	PGconn *	connection,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params,
		GNUNET_PQ_PostgresResultHandler	rh,
		void *	rh_cls
	)

Execute a named prepared statement that is a SELECT statement which may return multiple results in connection using the given params.

Call rh with the results. Returns the query status including the number of results given to rh (possibly zero). rh will not have been called if the return value is negative.

Parameters

connection	connection to execute the statement in
statement_name	name of the statement
params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)
rh	function to call with the result set, NULL to ignore
rh_cls	closure to pass to rh

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus.

Definition at line 194 of file pq_eval.c.

References GNUNET_PQ_eval_result(), GNUNET_PQ_exec_prepared(), result, and ret.

Referenced by namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), namestore_postgres_zone_to_name(), postgres_plugin_get(), postgres_plugin_get_closest(), postgres_plugin_get_expiration(), postgres_plugin_get_key(), postgres_plugin_get_keys(), postgres_plugin_get_replication(), and postgres_plugin_get_zero_anonymity().

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;
  unsigned int ret;

  result = GNUNET_PQ_exec_prepared(connection,
                                   statement_name,
                                   params);
  qs = GNUNET_PQ_eval_result(connection,
                             statement_name,
                             result);
  if (qs < 0)
    {
      PQclear(result);
      return qs;
    }
  ret = PQntuples(result);
  if (NULL != rh)
    rh(rh_cls,
       result,
       ret);
  PQclear(result);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_eval_prepared_singleton_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_singleton_select	(	PGconn *	connection,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params,
		struct GNUNET_PQ_ResultSpec *	rs
	)

Execute a named prepared statement that is a SELECT statement which must return a single result in connection using the given params.

Stores the result (if any) in rs, which the caller must then clean up using GNUNET_PQ_cleanup_result() if the return value was GNUNET_DB_STATUS_SUCCESS_ONE_RESULT. Returns the resulting session status.

Parameters

	connection	connection to execute the statement in
	statement_name	name of the statement
	params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)
[in,out]	rs	result specification to use for storing the result of the query

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus.

Definition at line 241 of file pq_eval.c.

References GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_OK, GNUNET_PQ_eval_result(), GNUNET_PQ_exec_prepared(), GNUNET_PQ_extract_result(), and result.

Referenced by namecache_postgres_lookup_block(), postgres_plugin_del(), postgres_plugin_estimate_size(), and postgres_plugin_get_random().

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;

  result = GNUNET_PQ_exec_prepared(connection,
                                   statement_name,
                                   params);
  qs = GNUNET_PQ_eval_result(connection,
                             statement_name,
                             result);
  if (qs < 0)
    {
      PQclear(result);
      return qs;
    }
  if (0 == PQntuples(result))
    {
      PQclear(result);
      return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
    }
  if (1 != PQntuples(result))
    {
      /* more than one result, but there must be at most one */
      GNUNET_break(0);
      PQclear(result);
      return GNUNET_DB_STATUS_HARD_ERROR;
    }
  if (GNUNET_OK !=
      GNUNET_PQ_extract_result(result,
                               rs,
                               0))
    {
      PQclear(result);
      return GNUNET_DB_STATUS_HARD_ERROR;
    }
  PQclear(result);
  return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
}

Here is the call graph for this function:

Here is the caller graph for this function: