1 files changed, 832 insertions, 51 deletions

diff --git a/src/include/gnunet_pq_lib.h b/src/include/gnunet_pq_lib.h
index fe3fabbea..8b4077d0e 100644
--- a/src/include/gnunet_pq_lib.h
+++ b/src/include/gnunet_pq_lib.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet
-   Copyright (C) 2016, 2017, 2020, 2021 GNUnet e.V.
+   Copyright (C) 2016, 2017, 2020-2022 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,9 +25,19 @@
 #ifndef GNUNET_PQ_LIB_H
 #define GNUNET_PQ_LIB_H
 
+
 #include <libpq-fe.h>
+#include <stdint.h>
+#include "gnunet_common.h"
+#include "gnunet_time_lib.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_db_lib.h"
+#include "postgres_ext.h"
+
+/**
+ * Postgres context.
+ */
+struct GNUNET_PQ_Context;
 
 /* ************************* pq_query_helper.c functions ************************ */
 
@@ -57,6 +67,14 @@ typedef int
                              void *scratch[],
                              unsigned int scratch_length);
 
+/**
+ * Function called to cleanup the closure of SQL parameters converter. Will be
+ * called with GNUNET_PQ_query_params_cleanup
+ *
+ * @param cls closure
+ */
+typedef void
+(*GNUNET_PQ_QueryConverter_Cleanup)(void *cls);
 
 /**
  * @brief Description of a DB query parameter.
@@ -70,10 +88,20 @@ struct GNUNET_PQ_QueryParam
 
   /**
    * Closure for @e conv.
+   * The function @conv_cls_cleanup can be set to cleanup the closure.
+   * The cleanup of the closure MUST be triggered manually by a call to
+   * GNUNET_PQ_query_params_cleanup.
    */
   void *conv_cls;
 
   /**
+   * Function to cleanup the closure @a conv_cls, may be NULL.
+   * The cleanup of the closure MUST be triggered manually by a call to
+   * GNUNET_PQ_query_params_cleanup.
+   */
+  GNUNET_PQ_QueryConverter_Cleanup conv_cls_cleanup;
+
+  /**
    * Data or NULL.
    */
   const void *data;
@@ -90,13 +118,26 @@ struct GNUNET_PQ_QueryParam
 
 };
 
+/**
+ * Must be called to cleanup memory from closures after the query parameters
+ * have been used as much as needed.
+ *
+ * @param params Array of GNUNET_PQ_QueryParam which must terminate with a GNUNET_PQ_query_param_end
+ */
+void
+GNUNET_PQ_cleanup_query_params_closures (
+  const struct GNUNET_PQ_QueryParam *params);
 
 /**
  * End of query parameter specification.
  */
 #define GNUNET_PQ_query_param_end \
   {                               \
-    NULL, NULL, NULL, 0, 0        \
+    .conv = NULL,                 \
+    .conv_cls = NULL,             \
+    .data = NULL,                 \
+    .size = 0,                    \
+    .num_params = 0               \
   }
 
 
@@ -114,7 +155,7 @@ GNUNET_PQ_query_param_null (void);
  * @a ptr_size bytes.
  *
  * @param ptr pointer to the query parameter to pass
- * @oaran ptr_size number of bytes in @a ptr
+ * @param ptr_size number of bytes in @a ptr
  * @return query parameter to use
  */
 struct GNUNET_PQ_QueryParam
@@ -133,6 +174,220 @@ GNUNET_PQ_query_param_string (const char *ptr);
 
 
 /**
+ * Pass a boolean into a query.
+ *
+ * @param b boolean bit to pass
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_bool (bool b);
+
+/**
+ * Returns the oid for a given datatype by name.
+ *
+ * @param db The db-connection
+ * @param name The name of the datatype
+ * @param[out] oid The OID of the datatype.
+ * @return GNUNET_OK when the datatype was found, GNUNET_SYSERR otherwise
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_PQ_get_oid_by_name (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  Oid *oid);
+
+
+/**
+ * The header for a postgresql array in binary format. note that this a
+ * simplified special case of the general structure (which contains pointers),
+ * as we only support one-dimensional arrays.
+ *
+ * Note that all values must be in network-byte-order.
+ */
+struct GNUNET_PQ_ArrayHeader_P
+{
+  uint32_t ndim;     /* number of dimensions. we only support ndim = 1 */
+  uint32_t has_null;
+  uint32_t oid;      /* oid of the elements */
+  uint32_t dim;      /* size of the array */
+  uint32_t lbound;   /* index value of first element in the db (default: 1). */
+} __attribute__((packed));
+
+
+/**
+ * Generate query parameter for an array of bool in host byte order.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num boolean elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_bool (
+  unsigned int num,
+  const bool *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of uint16_t in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT2_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num uint16 elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_uint16 (
+  unsigned int num,
+  const uint16_t *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of uint32_t in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT4_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous Array of @a num uint32_t elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_uint32 (
+  unsigned int num,
+  const uint32_t *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of uint64 in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT8_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num uint64_t elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_uint64 (
+  unsigned int num,
+  const uint64_t *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of buffers @a elements, each of
+ * corresponding size given in @a sizes.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continous array of @a num buffers, each of corresponding size given in @a sizes.
+ * @param sizes Pointer to sizes in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_bytes (
+  unsigned int num,
+  const void *elements,
+  const size_t *sizes,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of buffers @a elements,
+ * each of the same size @a size.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continous array of @a num buffers, each with the same size @a same_size
+ * @param same_size Size in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_bytes_same_size (
+  unsigned int num,
+  const void *elements,
+  size_t same_size,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate array of equal-sized query parameter with size determined
+ * by variable type from a pointer to an continuous array.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of the query parameter to pass.
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+#define GNUNET_PQ_query_param_array_auto_from_type(num, elements, db) \
+  GNUNET_PQ_query_param_array_bytes_same_size ((num), \
+                                               (elements), \
+                                               sizeof(*(elements)), \
+                                               (db))
+
+/**
+ * Generate query parameter for an array of pointers to buffers @a elements,
+ * each of the same size @a size.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to buffers, each with the same size @a same_size
+ * @param same_size Size in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_ptrs_bytes_same_size (
+  unsigned int num,
+  const void *elements[static num],
+  size_t same_size,
+  struct GNUNET_PQ_Context *db);
+
+
+/**
+ * Generate array of equal-sized query parameter with size determined by
+ * variable type from a pointer to an array of pointers to objects of the same
+ * type.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of the query parameter to pass.
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+#define GNUNET_PQ_query_param_array_ptrs_auto_from_type(num, elements, db) \
+  GNUNET_PQ_query_param_array_ptrs_bytes_same_size ((num), \
+                                                    (const void **) (elements), \
+                                                    sizeof(*(elements[0])), \
+                                                    (db))
+
+
+/**
+ * Generate query parameter for an array of strings (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num continuous strings (zero-terminated each)
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_string (
+  unsigned int num,
+  const char *elements,
+  struct GNUNET_PQ_Context *db);
+
+
+/**
+ * Generate query parameter for an array of strings (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointer to strings
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_ptrs_string (
+  unsigned int num,
+  const char *elements[static num],
+  struct GNUNET_PQ_Context *db);
+
+
+/**
  * Generate fixed-size query parameter with size determined
  * by variable type.
  *
@@ -142,6 +397,83 @@ GNUNET_PQ_query_param_string (const char *ptr);
 #define GNUNET_PQ_query_param_auto_from_type(x) \
   GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))
 
+/**
+ * Generate query parameter for an array of absolute time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num absolute timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_abs_time (
+  unsigned int num,
+  const struct GNUNET_TIME_Absolute *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of absolute time stamps (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to absolute timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_ptrs_abs_time (
+  unsigned int num,
+  const struct GNUNET_TIME_Absolute *elements[],
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of relative time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num relative timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_rel_time (
+  unsigned int num,
+  const struct GNUNET_TIME_Relative *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of relative time stamps (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to relative timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_ptrs_rel_time (
+  unsigned int num,
+  const struct GNUNET_TIME_Relative *elements[],
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_timestamp (
+  unsigned int num,
+  const struct GNUNET_TIME_Timestamp *elements,
+  struct GNUNET_PQ_Context *db);
+
+/**
+ * Generate query parameter for an array of time stamps (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to relative timestamps
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_array_ptrs_timestamp (
+  unsigned int num,
+  const struct GNUNET_TIME_Timestamp *elements[],
+  struct GNUNET_PQ_Context *db);
 
 /**
  * Generate query parameter for an RSA public key.  The
@@ -190,6 +522,17 @@ GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x);
 
 
 /**
+ * Generate query parameter for a timestamp.
+ * The database must store a 64-bit integer.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_timestamp (const struct GNUNET_TIME_Timestamp *x);
+
+
+/**
  * Generate query parameter for an absolute time value.
  * The database must store a 64-bit integer.
  *
@@ -202,6 +545,18 @@ GNUNET_PQ_query_param_absolute_time_nbo (
 
 
 /**
+ * Generate query parameter for a timestamp in NBO.
+ * The database must store a 64-bit integer.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_timestamp_nbo (
+  const struct GNUNET_TIME_TimestampNBO *x);
+
+
+/**
  * Generate query parameter for an uint16_t in host byte order.
  *
  * @param x pointer to the query parameter to pass
@@ -222,7 +577,7 @@ GNUNET_PQ_query_param_uint32 (const uint32_t *x);
 
 
 /**
- * Generate query parameter for an uint16_t in host byte order.
+ * Generate query parameter for an uint64_t in host byte order.
  *
  * @param x pointer to the query parameter to pass
  * @return query parameter to use
@@ -231,6 +586,37 @@ struct GNUNET_PQ_QueryParam
 GNUNET_PQ_query_param_uint64 (const uint64_t *x);
 
 
+/**
+ * Generate query parameter for an int64_t in host byte order.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_int64 (const int64_t *x);
+
+/**
+ * Generate query parameter for a blind sign public key.
+ * Internally, the various attributes of the public key
+ * will be serialized into on variable-size BLOB.
+ *
+ * @param pub pointer to the query parameter to pass
+ *
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_blind_sign_pub (
+  const struct GNUNET_CRYPTO_BlindSignPublicKey *pub);
+
+/**
+ * Generate query parameter for a blind sign private key of variable size.
+ *
+ * @param priv pointer to the query parameter to pass
+ *
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_blind_sign_priv (
+  const struct GNUNET_CRYPTO_BlindSignPrivateKey *priv);
+
 /* ************************* pq_result_helper.c functions ************************ */
 
 
@@ -280,8 +666,7 @@ struct GNUNET_PQ_ResultSpec
   GNUNET_PQ_ResultConverter conv;
 
   /**
-   * Function to clean up result data, NULL if cleanup is
-   * not necessary.
+   * Function to clean up result data, NULL if cleanup is not necessary.
    */
   GNUNET_PQ_ResultCleanup cleaner;
 
@@ -296,9 +681,9 @@ struct GNUNET_PQ_ResultSpec
   void *dst;
 
   /**
-   * Allowed size for the data, 0 for variable-size
-   * (in this case, the type of @e dst is a `void **`
-   * and we need to allocate a buffer of the right size).
+   * Allowed size for the data, 0 for variable-size (in this case, the type of
+   * @e dst is a `void **` and we need to allocate a buffer of the right
+   * size).
    */
   size_t dst_size;
 
@@ -318,10 +703,8 @@ struct GNUNET_PQ_ResultSpec
   bool is_nullable;
 
   /**
-   * Points to a location where we should store
-   * "true" if the result found is NULL, and
-   * otherwise "false". Only used if @e is_nullable
-   * is true.
+   * Points to a location where we should store "true" if the result found is
+   * NULL, and otherwise "false". Only used if @e is_nullable is true.
    */
   bool *is_null;
 
@@ -335,13 +718,20 @@ struct GNUNET_PQ_ResultSpec
  */
 #define GNUNET_PQ_result_spec_end         \
   {                                       \
-    NULL, NULL, NULL, NULL, 0, NULL, NULL \
+    .conv = NULL,                         \
+    .cleaner = NULL,                      \
+    .cls = NULL,                          \
+    .dst = NULL,                          \
+    .dst_size = 0,                        \
+    .fname = NULL,                        \
+    .result_size = NULL,                  \
+    .is_nullable = false,                 \
+    .is_null = NULL                       \
   }
 
 
 /**
- * Allow NULL value to be found in the database
- * for the given value.
+ * Allow NULL value to be found in the database for the given value.
  *
  * @param rs result spec entry to modify
  * @param[out] is_null location set to 'true' if the
@@ -377,7 +767,9 @@ GNUNET_PQ_result_spec_variable_size (const char *name,
  * @return array entry for the result specification to use
  */
 struct GNUNET_PQ_ResultSpec
-GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size);
+GNUNET_PQ_result_spec_fixed_size (const char *name,
+                                  void *dst,
+                                  size_t dst_size);
 
 
 /**
@@ -399,7 +791,20 @@ GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size);
  * @return array entry for the result specification to use
  */
 struct GNUNET_PQ_ResultSpec
-GNUNET_PQ_result_spec_string (const char *name, char **dst);
+GNUNET_PQ_result_spec_string (const char *name,
+                              char **dst);
+
+
+/**
+ * boolean expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] dst where to store the result
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_bool (const char *name,
+                            bool *dst);
 
 
 /**
@@ -439,6 +844,18 @@ GNUNET_PQ_result_spec_absolute_time (const char *name,
 
 
 /**
+ * Timestamp expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] t where to store the result
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_timestamp (const char *name,
+                                 struct GNUNET_TIME_Timestamp *t);
+
+
+/**
  * Relative time expected.
  *
  * @param name name of the field in the table
@@ -463,6 +880,18 @@ GNUNET_PQ_result_spec_absolute_time_nbo (const char *name,
 
 
 /**
+ * Timestamp expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] tn where to store the result
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_timestamp_nbo (const char *name,
+                                     struct GNUNET_TIME_TimestampNBO *tn);
+
+
+/**
  * uint16_t expected.
  *
  * @param name name of the field in the table
@@ -470,7 +899,8 @@ GNUNET_PQ_result_spec_absolute_time_nbo (const char *name,
  * @return array entry for the result specification to use
  */
 struct GNUNET_PQ_ResultSpec
-GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16);
+GNUNET_PQ_result_spec_uint16 (const char *name,
+                              uint16_t *u16);
 
 
 /**
@@ -481,7 +911,8 @@ GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16);
  * @return array entry for the result specification to use
  */
 struct GNUNET_PQ_ResultSpec
-GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32);
+GNUNET_PQ_result_spec_uint32 (const char *name,
+                              uint32_t *u32);
 
 
 /**
@@ -492,16 +923,235 @@ GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32);
  * @return array entry for the result specification to use
  */
 struct GNUNET_PQ_ResultSpec
-GNUNET_PQ_result_spec_uint64 (const char *name, uint64_t *u64);
+GNUNET_PQ_result_spec_uint64 (const char *name,
+                              uint64_t *u64);
 
 
-/* ************************* pq.c functions ************************ */
+/**
+ * int64_t expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] i64 where to store the result
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_int64 (const char *name,
+                             int64_t *i64);
+
 
 /**
- * Postgres context.
+ * array of bool expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a bools.
+ * @param[out] bools pointer to where to store the result, an array of @a num bool's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
  */
-struct GNUNET_PQ_Context;
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_bool (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  bool **bools);
+
+/**
+ * array of uint16_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u16s.
+ * @param[out] dst pointer to where to store the an array of @a num uint16_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_uint16 (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  uint16_t **dst);
+
+/**
+ * array of uint32_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u32s.
+ * @param[out] dst pointer to where to store the array of @a num uint32_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_uint32 (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  uint32_t **dst);
+
+/**
+ * array of uint64_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num uint64_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_uint64 (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  uint64_t **dst);
+
+
+/**
+ * array of absolute time expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num absolute time. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_abs_time (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  struct GNUNET_TIME_Absolute **dst);
+
+/**
+ * array of relative time expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num relate time. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_rel_time (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  struct GNUNET_TIME_Relative **dst);
+
+/**
+ * array of relative time expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num timestamps. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_timestamp (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  struct GNUNET_TIME_Timestamp **dst);
+
+/**
+ * Array of variable-size result expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements
+ * @param[out] sizes where to store the @a num size's of byte-buffers in @a dst
+ * @param[out] dst where to store the continuous array of @a num byte-buffers , allocated
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_variable_size (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  size_t **sizes,
+  void **dst);
+
+
+/**
+ * Array of fixed-size result expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param size number of bytes expected in each element of @a dst
+ * @param[out] num where to store the number of elements
+ * @param[out] dst where to store the results, an continuous array of fixed-size elements
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_fixed_size (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t size,
+  size_t *num,
+  void **dst);
+
+
+/**
+ * We expect a fixed-size result, with size determined by the type of `* dst`
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param num pointer to where to store the number of elements
+ * @param dst pointer to where to store the results, type fits expected result size
+ * @return array entry for the result specification to use
+ */
+#define GNUNET_PQ_result_spec_auto_array_from_type(db, name, num, dst) \
+  GNUNET_PQ_result_spec_array_fixed_size ( \
+    (db), \
+    (name), \
+    sizeof(*(dst)), \
+    (num), \
+    (void *) &(dst))
+
+
+/**
+ * Array of 0-terminated strings expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements
+ * @param[out] dst where to store the allocated continous array of @a num 0-terminated strings
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_string (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  char **dst);
+
+
+/**
+ * Blind sign public key expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] public_key where to store the denomination signature
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_blind_sign_pub (
+  const char *name,
+  struct GNUNET_CRYPTO_BlindSignPublicKey *public_key);
+
+
+/**
+ * Blind sign private key expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] private_key where to store the denomination signature
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_blind_sign_priv (
+  const char *name,
+  struct GNUNET_CRYPTO_BlindSignPrivateKey *private_key);
 
+/* ************************* pq.c functions ************************ */
 
 /**
  * Execute a prepared statement.
@@ -641,11 +1291,11 @@ GNUNET_PQ_eval_prepared_multi_select (struct GNUNET_PQ_Context *db,
  *         codes to `enum GNUNET_DB_QueryStatus`.
  */
 enum GNUNET_DB_QueryStatus
-GNUNET_PQ_eval_prepared_singleton_select (struct GNUNET_PQ_Context *db,
-                                          const char *statement_name,
-                                          const struct
-                                          GNUNET_PQ_QueryParam *params,
-                                          struct GNUNET_PQ_ResultSpec *rs);
+GNUNET_PQ_eval_prepared_singleton_select (
+  struct GNUNET_PQ_Context *db,
+  const char *statement_name,
+  const struct GNUNET_PQ_QueryParam *params,
+  struct GNUNET_PQ_ResultSpec *rs);
 
 
 /* ******************** pq_prepare.c functions ************** */
@@ -667,11 +1317,6 @@ struct GNUNET_PQ_PreparedStatement
    */
   const char *sql;
 
-  /**
-   * Number of arguments included in @e sql.
-   */
-  unsigned int num_arguments;
-
 };
 
 
@@ -680,7 +1325,7 @@ struct GNUNET_PQ_PreparedStatement
  */
 #define GNUNET_PQ_PREPARED_STATEMENT_END \
   {                                      \
-    NULL, NULL, 0                        \
+    NULL, NULL                           \
   }
 
 
@@ -689,13 +1334,11 @@ struct GNUNET_PQ_PreparedStatement
  *
  * @param name name of the statement
  * @param sql actual SQL statement
- * @param num_args number of arguments in the statement
  * @return initialized struct
  */
 struct GNUNET_PQ_PreparedStatement
 GNUNET_PQ_make_prepare (const char *name,
-                        const char *sql,
-                        unsigned int num_args);
+                        const char *sql);
 
 
 /**
@@ -707,11 +1350,27 @@ GNUNET_PQ_make_prepare (const char *name,
  * @return #GNUNET_OK on success,
  *         #GNUNET_SYSERR on error
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_PQ_prepare_statements (struct GNUNET_PQ_Context *db,
                               const struct GNUNET_PQ_PreparedStatement *ps);
 
 
+/**
+ * Request creation of prepared statements @a ps from Postgres, but do not
+ * automatically re-prepare the statement if we are disconnected from the
+ * database.
+ *
+ * @param db database to prepare the statements for
+ * @param ps #GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared
+ *            statements.
+ * @return #GNUNET_OK on success,
+ *         #GNUNET_SYSERR on error
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_PQ_prepare_once (struct GNUNET_PQ_Context *db,
+                        const struct GNUNET_PQ_PreparedStatement *ps);
+
+
 /* ******************** pq_exec.c functions ************** */
 
 
@@ -766,13 +1425,13 @@ GNUNET_PQ_make_try_execute (const char *sql);
 /**
  * Request execution of an array of statements @a es from Postgres.
  *
- * @param pq database to execute the statements in
+ * @param db database to execute the statements in
  * @param es #GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared
  *            statements.
  * @return #GNUNET_OK on success (modulo statements where errors can be ignored)
  *         #GNUNET_SYSERR on error
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_PQ_exec_statements (struct GNUNET_PQ_Context *db,
                            const struct GNUNET_PQ_ExecuteStatement *es);
 
@@ -781,18 +1440,41 @@ GNUNET_PQ_exec_statements (struct GNUNET_PQ_Context *db,
 
 
 /**
+ * Flags to control PQ operation.
+ */
+enum GNUNET_PQ_Options
+{
+  /**
+   * Traditional default. Do nothing special.
+   */
+  GNUNET_PQ_FLAG_NONE = 0,
+
+  /**
+   * Dropping database. Do not attempt to initialize
+   * versioning schema if not present.
+   */
+  GNUNET_PQ_FLAG_DROP = 1,
+
+  /**
+   * Check database version is current.  Fail to connect if it is not.
+   */
+  GNUNET_PQ_FLAG_CHECK_CURRENT = 2
+};
+
+
+/**
  * Create a connection to the Postgres database using @a config_str for the
  * configuration.  Initialize logging via GNUnet's log routines and disable
  * Postgres's logger.  Also ensures that the statements in @a load_path and @a
  * es are executed whenever we (re)connect to the database, and that the
- * prepared statements in @a ps are "ready".  If statements in @es fail that
+ * prepared statements in @a ps are "ready".  If statements in @a es fail that
  * were created with #GNUNET_PQ_make_execute(), then the entire operation
  * fails.
  *
  * In @a load_path, a list of "$XXXX.sql" files is expected where $XXXX
  * must be a sequence of contiguous integer values starting at 0000.
  * These files are then loaded in sequence using "psql $config_str" before
- * running statements from @e es.  The directory is inspected again on
+ * running statements from @a es.  The directory is inspected again on
  * reconnect.
  *
  * @param config_str configuration to use
@@ -810,10 +1492,58 @@ GNUNET_PQ_connect (const char *config_str,
 
 
 /**
- * Connect to a postgres database using the configuration
- * option "CONFIG" in @a section.  Also ensures that the
- * statements in @a es are executed whenever we (re)connect to the
- * database, and that the prepared statements in @a ps are "ready".
+ * Execute SQL statements from @a buf against @a db.
+ * The given filename infix in @a buf is prefixed with
+ * the "load_path" and ".sql" is appended to construct
+ * the full filename.
+ *
+ * @param db database context to use
+ * @param buf filename infix (!) with the SQL code to run
+ * @return #GNUNET_OK on success, #GNUNET_NO if patch @a buf does not exist, #GNUNET_SYSERR on error
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db,
+                    const char *buf);
+
+
+/**
+ * Create a connection to the Postgres database using @a config_str for the
+ * configuration.  Initialize logging via GNUnet's log routines and disable
+ * Postgres's logger.  Also ensures that the statements in @a load_path and @a
+ * es are executed whenever we (re)connect to the database, and that the
+ * prepared statements in @a ps are "ready".  If statements in @a es fail that
+ * were created with #GNUNET_PQ_make_execute(), then the entire operation
+ * fails.
+ *
+ * In @a load_path, a list of "$XXXX.sql" files is expected where $XXXX
+ * must be a sequence of contiguous integer values starting at 0000.
+ * These files are then loaded in sequence using "psql $config_str" before
+ * running statements from @e es.  The directory is inspected again on
+ * reconnect.
+ *
+ * @param config_str configuration to use
+ * @param load_path path to directory with SQL transactions to run, can be NULL
+ * @param auto_suffix infix of SQL series to run on every reconnect; runs multiple (!) files, of the form auto_suffix-XXXX where XXXX is from 0 to 9999 (consequtive).
+ * @param es #GNUNET_PQ_PREPARED_STATEMENT_END-terminated
+ *            array of statements to execute upon EACH connection, can be NULL
+ * @param ps array of prepared statements to prepare, can be NULL
+ * @param flags connection flags
+ * @return NULL on error
+ */
+struct GNUNET_PQ_Context *
+GNUNET_PQ_connect2 (const char *config_str,
+                    const char *load_path,
+                    const char *auto_suffix,
+                    const struct GNUNET_PQ_ExecuteStatement *es,
+                    const struct GNUNET_PQ_PreparedStatement *ps,
+                    enum GNUNET_PQ_Options flags);
+
+
+/**
+ * Connect to a postgres database using the configuration option "CONFIG" in
+ * @a section.  Also ensures that the statements in @a es are executed
+ * whenever we (re)connect to the database, and that the prepared statements
+ * in @a ps are "ready".
  *
  * The caller does not have to ensure that @a es and @a ps remain allocated
  * and initialized in memory until #GNUNET_PQ_disconnect() is called, as a copy will be made.
@@ -835,6 +1565,34 @@ GNUNET_PQ_connect_with_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
+ * Connect to a postgres database using the configuration
+ * option "CONFIG" in @a section.  Also ensures that the
+ * statements in @a es are executed whenever we (re)connect to the
+ * database, and that the prepared statements in @a ps are "ready".
+ *
+ * The caller does not have to ensure that @a es and @a ps remain allocated
+ * and initialized in memory until #GNUNET_PQ_disconnect() is called, as a
+ * copy will be made.
+ *
+ * @param cfg configuration
+ * @param section configuration section to use to get Postgres configuration options
+ * @param load_path_suffix suffix to append to the SQL_DIR in the configuration
+ * @param es #GNUNET_PQ_PREPARED_STATEMENT_END-terminated
+ *            array of statements to execute upon EACH connection, can be NULL
+ * @param ps array of prepared statements to prepare, can be NULL
+ * @param flags connection flags
+ * @return the postgres handle, NULL on error
+ */
+struct GNUNET_PQ_Context *
+GNUNET_PQ_connect_with_cfg2 (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                             const char *section,
+                             const char *load_path_suffix,
+                             const struct GNUNET_PQ_ExecuteStatement *es,
+                             const struct GNUNET_PQ_PreparedStatement *ps,
+                             enum GNUNET_PQ_Options flags);
+
+
+/**
  * Reinitialize the database @a db if the connection is down.
  *
  * @param db database connection to reinitialize
@@ -893,12 +1651,24 @@ GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh);
 
 
 /**
+ * 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.
+ *
+ * @param[in,out] db database to check for events
+ */
+void
+GNUNET_PQ_event_do_poll (struct GNUNET_PQ_Context *db);
+
+
+/**
  * Notify all that listen on @a 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 @a db. However, the @a cb
- * will always be called from the thread that runs
+ * Unlike many other calls, this function is thread-safe and may be called
+ * from threads that are different from the one that setup @a db. However, the
+ * @a cb will always be called from the thread that runs
  * #GNUNET_PQ_event_do_poll() or the GNUnet scheduler.
  *
  * @param db database context to use
@@ -914,6 +1684,17 @@ GNUNET_PQ_event_notify (struct GNUNET_PQ_Context *db,
 
 
 /**
+ * Compute the channel that one should notify upon for the given event
+ * specification.
+ *
+ * @param es event specification
+ * @return channel to notify upon
+ */
+char *
+GNUNET_PQ_get_event_notify_channel (const struct GNUNET_DB_EventHeaderP *es);
+
+
+/**
  * Within the @a db context, run all the SQL files
  * from the @a load_path from 0000-9999.sql (as long
  * as the files exist contiguously).