pq_event.c File Reference

event notifications via Postgres More...

#include "platform.h"
#include "pq.h"
#include <pthread.h>

Include dependency graph for pq_event.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_DB_EventHandler
	Handle for an active LISTENer to the database. More...
struct	NotifyContext
	Closure for do_notify(). More...

Functions
static void	es_to_sh (const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_ShortHashCode *sh)
	Convert es to a short hash. More...
static char *	sh_to_channel (struct GNUNET_ShortHashCode *sh, char identifier[64])
	Convert sh to a Postgres identifier. More...
static enum GNUNET_GenericReturnValue	channel_to_sh (const char *identifier, struct GNUNET_ShortHashCode *sh)
	Convert sh to a Postgres identifier. More...
static char *	es_to_channel (const struct GNUNET_DB_EventHeaderP *es, char identifier[64])
	Convert es to a Postgres identifier. More...
static enum GNUNET_GenericReturnValue	do_notify (void *cls, const struct GNUNET_ShortHashCode *sh, void *value)
	Function called on every event handler that needs to be triggered. More...
void	GNUNET_PQ_event_do_poll (struct GNUNET_PQ_Context *db)
	Poll for events right now. More...
static void	do_scheduler_notify (void *cls)
	The GNUnet scheduler notifies us that we need to trigger the DB event poller. More...
static void	scheduler_fd_cb (void *cls, int fd)
	Function called when the Postgres FD changes and we need to update the scheduler event loop task. More...
static void	manage_subscribe (struct GNUNET_PQ_Context *db, const char *cmd, struct GNUNET_DB_EventHandler *eh)
	Helper function to trigger an SQL cmd on db. More...
static enum GNUNET_GenericReturnValue	register_notify (void *cls, const struct GNUNET_ShortHashCode *sh, void *value)
	Re-subscribe to notifications after disconnect. More...
void	GNUNET_PQ_event_reconnect_ (struct GNUNET_PQ_Context *db, int fd)
	Internal API. More...
static void	event_timeout (void *cls)
	Function run on timeout for an event. More...
struct GNUNET_DB_EventHandler *	GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_TIME_Relative timeout, GNUNET_DB_EventCallback cb, void *cb_cls)
	Register callback to be invoked on events of type es. More...
void	GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh)
	Stop notifications. More...
char *	GNUNET_PG_get_event_notify_channel (const struct GNUNET_DB_EventHeaderP *es)
	Compute the channel that one should notify upon for the given event specification. More...
void	GNUNET_PQ_event_notify (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, const void *extra, size_t extra_size)
	Notify all that listen on es of an event. More...

Detailed Description

event notifications via Postgres

Author

Christian Grothoff

Definition in file pq_event.c.

Function Documentation

es_to_sh()

static void es_to_sh ( const struct GNUNET_DB_EventHeaderP *  es, struct GNUNET_ShortHashCode *  sh  )

static

Convert es to a short hash.

Parameters

	es	spec to hash to an identifier
[out]	sh	short hash to set

Definition at line 69 of file pq_event.c.

{
  struct GNUNET_HashCode h_channel;
 
  GNUNET_CRYPTO_hash (es,
                      ntohs (es->size),
                      &h_channel);
  GNUNET_static_assert (sizeof (*sh) <= sizeof (h_channel));
  memcpy (sh,
          &h_channel,
          sizeof (*sh));
}

References GNUNET_CRYPTO_hash(), GNUNET_static_assert, sh, and GNUNET_DB_EventHeaderP::size.

Referenced by do_notify(), and GNUNET_PQ_event_listen().

Here is the call graph for this function:

Here is the caller graph for this function:

sh_to_channel()

static char* sh_to_channel ( struct GNUNET_ShortHashCode *  sh, char  identifier[64]  )

static

Convert sh to a Postgres identifier.

Parameters

	sh	short hash to convert to an identifier
[out]	identifier	by default, Postgres supports NAMEDATALEN=64 character identifiers

Returns

end position of the identifier

Definition at line 93 of file pq_event.c.

{
  char *end;
 
  end = GNUNET_STRINGS_data_to_string (sh,
                                       sizeof (*sh),
                                       identifier,
                                       63);
  GNUNET_assert (NULL != end);
  *end = '\0';
  return end;
}

Referenced by do_notify(), and manage_subscribe().

Here is the caller graph for this function:

channel_to_sh()

static enum GNUNET_GenericReturnValue channel_to_sh ( const char *  identifier, struct GNUNET_ShortHashCode *  sh  )

static

Convert sh to a Postgres identifier.

Parameters

	identifier	to convert
[out]	sh	set to short hash

Returns

GNUNET_OK on success

Definition at line 93 of file pq_event.c.

{
  return GNUNET_STRINGS_string_to_data (identifier,
                                        strlen (identifier),
                                        sh,
                                        sizeof (*sh));
}

References end, GNUNET_assert, GNUNET_STRINGS_data_to_string(), and sh.

Referenced by GNUNET_PQ_event_do_poll().

Here is the call graph for this function:

Here is the caller graph for this function:

es_to_channel()

static char* es_to_channel ( const struct GNUNET_DB_EventHeaderP *  es, char  identifier[64]  )

static

Convert es to a Postgres identifier.

Parameters

	es	spec to hash to an identifier
[out]	identifier	by default, Postgres supports NAMEDATALEN=64 character identifiers

Returns

end position of the identifier

Definition at line 135 of file pq_event.c.

{
  struct GNUNET_ShortHashCode sh;
 
  es_to_sh (es,
            &sh);
  return sh_to_channel (&sh,
                        identifier);
}

Referenced by GNUNET_PG_get_event_notify_channel().

Here is the caller graph for this function:

do_notify()

static enum GNUNET_GenericReturnValue do_notify ( void *  cls, const struct GNUNET_ShortHashCode *  sh, void *  value  )

static

Function called on every event handler that needs to be triggered.

Parameters

cls	a struct NotifyContext
sh	channel name
value	a struct GNUNET_DB_EventHandler

Returns

GNUNET_OK continue to iterate

Definition at line 135 of file pq_event.c.

{
  struct NotifyContext *ctx = cls;
  struct GNUNET_DB_EventHandler *eh = value;
 
  eh->cb (eh->cb_cls,
          ctx->extra,
          ctx->extra_size);
  return GNUNET_OK;
}

References es_to_sh(), sh, and sh_to_channel().

Referenced by GNUNET_PQ_event_do_poll().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_event_do_poll()

void GNUNET_PQ_event_do_poll

(

struct GNUNET_PQ_Context *

db

)

Poll for events right now.

Useful if we may have triggered an event for ourselves. Not needed when using GNUNET_PQ_event_notify(), but useful when stored procedures may have triggered events. Does nothing if there are no events.

Parameters

[in,out]

db

database to check for events

Definition at line 189 of file pq_event.c.

{
  PGnotify *n;
  unsigned int cnt = 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "PG poll job active\n");
  if (1 !=
      PQconsumeInput (db->conn))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read from Postgres: %s\n",
                PQerrorMessage (db->conn));
    if (CONNECTION_BAD != PQstatus (db->conn))
      return;
    GNUNET_PQ_reconnect (db);
    return;
  }
  while (NULL != (n = PQnotifies (db->conn)))
  {
    struct GNUNET_ShortHashCode sh;
    struct NotifyContext ctx = {
      .extra = NULL
    };
 
    cnt++;
    if ('X' != toupper ((int) n->relname[0]))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if (GNUNET_OK !=
        channel_to_sh (&n->relname[1],
                       &sh))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if ( (NULL != n->extra) &&
         (GNUNET_OK !=
          GNUNET_STRINGS_string_to_data_alloc (n->extra,
                                               strlen (n->extra),
                                               &ctx.extra,
                                               &ctx.extra_size)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported extra data `%s' on channel `%s'\n",
                  n->extra,
                  n->relname);
      PQfreemem (n);
      continue;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Received notification %s with extra data `%.*s'\n",
                n->relname,
                (int) ctx.extra_size,
                (const char *) ctx.extra);
    GNUNET_CONTAINER_multishortmap_get_multiple (db->channel_map,
                                                 &sh,
                                                 &do_notify,
                                                 &ctx);
    GNUNET_free (ctx.extra);
    PQfreemem (n);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "PG poll job finishes after %u events\n",
              cnt);
}

References channel_to_sh(), ctx, db, do_notify(), GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_PQ_reconnect(), GNUNET_STRINGS_string_to_data_alloc(), and sh.

Referenced by do_scheduler_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

do_scheduler_notify()

static void do_scheduler_notify ( void *  cls )

static

The GNUnet scheduler notifies us that we need to trigger the DB event poller.

Parameters

cls	a struct GNUNET_PQ_Context *

Definition at line 272 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
 
  db->event_task = NULL;
  if (NULL == db->rfd)
    GNUNET_PQ_reconnect (db);
  GNUNET_PQ_event_do_poll (db);
  if (NULL != db->event_task)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Resubscribing\n");
  if (NULL == db->rfd)
  {
    db->resubscribe_backoff
      = GNUNET_TIME_relative_max (db->resubscribe_backoff,
                                  GNUNET_TIME_UNIT_SECONDS);
    db->resubscribe_backoff
      = GNUNET_TIME_STD_BACKOFF (db->resubscribe_backoff);
    db->event_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                   &do_scheduler_notify,
                                                   db);
    return;
  }
  db->resubscribe_backoff = GNUNET_TIME_UNIT_SECONDS;
  db->event_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     db->rfd,
                                     &do_scheduler_notify,
                                     db);
}

References db, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_PQ_event_do_poll(), GNUNET_PQ_reconnect(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_relative_max(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_FOREVER_REL, and GNUNET_TIME_UNIT_SECONDS.

Referenced by scheduler_fd_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduler_fd_cb()

static void scheduler_fd_cb ( void *  cls, int  fd  )

static

Function called when the Postgres FD changes and we need to update the scheduler event loop task.

Parameters

cls	a struct GNUNET_PQ_Context *
fd	the file descriptor, possibly -1

Definition at line 313 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "New poll FD is %d\n",
              fd);
  if (NULL != db->event_task)
  {
    GNUNET_SCHEDULER_cancel (db->event_task);
    db->event_task = NULL;
  }
  GNUNET_free (db->rfd);
  if (-1 == fd)
    return;
  if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Activating poll job on %d\n",
              fd);
  db->rfd = GNUNET_NETWORK_socket_box_native (fd);
  db->event_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_ZERO,
                                     db->rfd,
                                     &do_scheduler_notify,
                                     db);
}

References db, do_scheduler_notify(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NETWORK_socket_box_native(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), and GNUNET_TIME_UNIT_ZERO.

Referenced by GNUNET_PQ_event_listen(), and GNUNET_PQ_event_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

manage_subscribe()

static void manage_subscribe ( struct GNUNET_PQ_Context *  db, const char *  cmd, struct GNUNET_DB_EventHandler *  eh  )

static

Helper function to trigger an SQL cmd on db.

Parameters

db	database to send command to
cmd	prefix of the command to send
eh	details about the event

Definition at line 351 of file pq_event.c.

{
  char sql[16 + 64];
  char *end;
  PGresult *result;
 
  if (NULL == db->conn)
    return;
  end = stpcpy (sql,
                cmd);
  end = sh_to_channel (&eh->sh,
                       end);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Executing PQ command `%s'\n",
              sql);
  result = PQexec (db->conn,
                   sql);
  if (PGRES_COMMAND_OK != PQresultStatus (result))
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Failed to execute `%s': %s/%s/%s/%s/%s",
                     sql,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
  }
  PQclear (result);
}

References db, end, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_from, result, GNUNET_DB_EventHandler::sh, and sh_to_channel().

Referenced by GNUNET_PQ_event_listen(), and GNUNET_PQ_event_listen_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

register_notify()

static enum GNUNET_GenericReturnValue register_notify ( void *  cls, const struct GNUNET_ShortHashCode *  sh, void *  value  )

static

Re-subscribe to notifications after disconnect.

Parameters

cls	the DB context
sh	the short hash of the channel
value	the event handler

Returns

GNUNET_OK to continue to iterate

Definition at line 351 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
  struct GNUNET_DB_EventHandler *eh = value;
 
  manage_subscribe (db,
                    "LISTEN X",
                    eh);
  return GNUNET_OK;
}

Referenced by GNUNET_PQ_event_reconnect_().

Here is the caller graph for this function:

GNUNET_PQ_event_reconnect_()

void GNUNET_PQ_event_reconnect_	(	struct GNUNET_PQ_Context *	db,
		int	fd
	)

Internal API.

Reconnect should re-register notifications after a disconnect.

Parameters

db	the DB handle
fd	socket to listen on

Definition at line 412 of file pq_event.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Change in PQ event FD to %d\n",
              fd);
  scheduler_fd_cb (db,
                   fd);
  GNUNET_CONTAINER_multishortmap_iterate (db->channel_map,
                                          &register_notify,
                                          db);
}

References db, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, register_notify(), and scheduler_fd_cb().

Referenced by GNUNET_PQ_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

event_timeout()

static void event_timeout ( void *  cls )

static

Function run on timeout for an event.

Triggers the notification, but does NOT clear the handler.

Parameters

cls	a struct GNUNET_DB_EventHandler *

Definition at line 433 of file pq_event.c.

{
  struct GNUNET_DB_EventHandler *eh = cls;
 
  eh->timeout_task = NULL;
  eh->cb (eh->cb_cls,
          NULL,
          0);
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, and GNUNET_DB_EventHandler::timeout_task.

Referenced by GNUNET_PQ_event_listen().

Here is the caller graph for this function:

GNUNET_PQ_event_listen()

struct GNUNET_DB_EventHandler* GNUNET_PQ_event_listen	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_DB_EventCallback	cb,
		void *	cb_cls
	)

Register callback to be invoked on events of type es.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to listen for
timeout	when to trigger cb based on timeout
cb	function to call when the event happens, possibly multiple times (until GNUNET_PQ_event_listen_cancel() is invoked), including on timeout
cb_cls	closure for cb

Returns

handle useful to cancel the listener

Definition at line 445 of file pq_event.c.

{
  struct GNUNET_DB_EventHandler *eh;
  bool sub;
 
  eh = GNUNET_new (struct GNUNET_DB_EventHandler);
  eh->db = db;
  es_to_sh (es,
            &eh->sh);
  eh->cb = cb;
  eh->cb_cls = cb_cls;
  sub = (NULL ==
         GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                             &eh->sh));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (db->channel_map,
                                                     &eh->sh,
                                                     eh,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  if (NULL == db->event_task)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Starting event scheduler\n");
    scheduler_fd_cb (db,
                     PQsocket (db->conn));
  }
  if (sub)
    manage_subscribe (db,
                      "LISTEN X",
                      eh);
  eh->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                   &event_timeout,
                                                   eh);
  return eh;
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, db, GNUNET_DB_EventHandler::db, es_to_sh(), event_timeout(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), manage_subscribe(), scheduler_fd_cb(), GNUNET_DB_EventHandler::sh, timeout, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PQ_event_listen_cancel()

void GNUNET_PQ_event_listen_cancel

(

struct GNUNET_DB_EventHandler *

eh

)

Stop notifications.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

eh	handle to unregister.

Definition at line 487 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = eh->db;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_remove (db->channel_map,
                                                        &eh->sh,
                                                        eh));
  if (NULL ==
      GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                          &eh->sh))
    manage_subscribe (db,
                      "UNLISTEN X",
                      eh);
  if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Stopping PQ event scheduler job\n");
    GNUNET_free (db->rfd);
    if (NULL != db->event_task)
    {
      GNUNET_SCHEDULER_cancel (db->event_task);
      db->event_task = NULL;
    }
  }
  if (NULL != eh->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (eh->timeout_task);
    eh->timeout_task = NULL;
  }
  GNUNET_free (eh);
}

References db, GNUNET_DB_EventHandler::db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_cancel(), manage_subscribe(), GNUNET_DB_EventHandler::sh, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PG_get_event_notify_channel()

char* GNUNET_PG_get_event_notify_channel

(

const struct GNUNET_DB_EventHeaderP *

es

)

Compute the channel that one should notify upon for the given event specification.

Parameters

es	event specification

Returns

channel to notify upon

Definition at line 522 of file pq_event.c.

{
  char sql[16 + 64 + 8];
  char *end;
 
  end = stpcpy (sql,
                "X");
  end = es_to_channel (es,
                       end);
  GNUNET_assert (NULL != end);
  return GNUNET_strdup (sql);
}

References end, GNUNET_PQ_Context::es, es_to_channel(), GNUNET_assert, and GNUNET_strdup.

Here is the call graph for this function:

GNUNET_PQ_event_notify()

void GNUNET_PQ_event_notify	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		const void *	extra,
		size_t	extra_size
	)

Notify all that listen on es of an event.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to generate
extra	additional event data provided
extra_size	number of bytes in extra

Definition at line 537 of file pq_event.c.

{
  char sql[16 + 64 + extra_size * 8 / 5 + 8];
  char *end;
  PGresult *result;
 
  end = stpcpy (sql,
                "NOTIFY X");
  end = es_to_channel (es,
                       end);
  end = stpcpy (end,
                ", '");
  end = GNUNET_STRINGS_data_to_string (extra,
                                       extra_size,
                                       end,
                                       sizeof (sql) - (end - sql) - 1);
  GNUNET_assert (NULL != end);
  *end = '\0';
  end = stpcpy (end,
                "'");
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Executing command `%s'\n",
              sql);
  result = PQexec (db->conn,
                   sql);
  if (PGRES_COMMAND_OK != PQresultStatus (result))
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Failed to execute `%s': %s/%s/%s/%s/%s",
                     sql,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
  }
  PQclear (result);
  GNUNET_PQ_event_do_poll (db);
}