Merge branch 'master' of taler.net:exchange

5 files changed, 1870 insertions, 72 deletions

diff --git a/src/auditordb/Makefile.am b/src/auditordb/Makefile.am
index e8ec40272..640f95f25 100644
--- a/src/auditordb/Makefile.am
+++ b/src/auditordb/Makefile.am
@@ -12,7 +12,8 @@ pkgcfg_DATA = \
   auditordb-postgres.conf
 
 EXTRA_DIST = \
-  auditordb-postgres.conf 
+  auditordb-postgres.conf \
+  test-auditor-db-postgres.conf
 
 plugindir = $(libdir)/taler
 
@@ -49,5 +50,21 @@ libtalerauditordb_la_LDFLAGS = \
   -no-undefined
 
 
-EXTRA_test_auditordb_postgres_DEPENDENCIES = \
-  libtaler_plugin_auditordb_postgres.la
+#EXTRA_test_auditordb_postgres_DEPENDENCIES = \
+#  libtaler_plugin_auditordb_postgres.la
+
+
+check_PROGRAMS = \
+  test-auditordb-postgres
+
+AM_TESTS_ENVIRONMENT=export TALER_PREFIX=$${TALER_PREFIX:-@libdir@};export PATH=$${TALER_PREFIX:-@prefix@}/bin:$$PATH;
+TESTS = \
+  test-auditordb-postgres
+
+test_auditordb_postgres_SOURCES = \
+  test_auditordb.c
+test_auditordb_postgres_LDADD = \
+  libtalerauditordb.la \
+  $(top_srcdir)/src/pq/libtalerpq.la \
+  $(top_srcdir)/src/util/libtalerutil.la \
+  -lgnunetutil
diff --git a/src/auditordb/plugin_auditordb_postgres.c b/src/auditordb/plugin_auditordb_postgres.c
index 3205d489c..fa3a6d465 100644
--- a/src/auditordb/plugin_auditordb_postgres.c
+++ b/src/auditordb/plugin_auditordb_postgres.c
@@ -326,7 +326,7 @@ postgres_create_tables (void *cls)
      of; "refund_serial_id" tells us the last entry in "refunds"
      for this denom_pub that the auditor is aware of. */
   SQLEXEC ("CREATE TABLE IF NOT EXISTS denomination_pending"
-	   "(denom_pub_hash BYTEA PRIMARY KEY REFERENCES denominations (denom_pub_hash) ON DELETE CASCADE"
+	   "(denom_pub_hash BYTEA PRIMARY KEY REFERENCES auditor_denominations (denom_pub_hash) ON DELETE CASCADE"
            ",denom_balance_val INT8 NOT NULL"
            ",denom_balance_frac INT4 NOT NULL"
            ",denom_balance_curr VARCHAR("TALER_CURRENCY_LEN_STR") NOT NULL"
@@ -435,8 +435,8 @@ postgres_create_tables (void *cls)
            ",reserve_profits_curr VARCHAR("TALER_CURRENCY_LEN_STR") NOT NULL"
 	   ")");
 
-  SQLEXEC_INDEX("CREATE INDEX historic_reserve_summary_by_master_pub_start_date"
-                " ON historic_ledger(master_pub,start_date)");
+  SQLEXEC_INDEX("CREATE INDEX historic_reserve_summary_by_master_pub_start_date "
+                "ON historic_reserve_summary(master_pub,start_date)");
 
 
   /* Table with historic business ledger; basically, when the exchange
@@ -510,13 +510,419 @@ postgres_prepare (PGconn *db_conn)
     PQclear (result); result = NULL;                            \
   } while (0);
 
-  /* Used in #postgres_XXX() */
-  PREPARE ("test_insert",
-           "INSERT INTO test "
-           "(test_pub"
-           ") VALUES "
-           "($1);",
+  /* Used in #postgres_insert_denomination_info() */
+  PREPARE ("auditor_denominations_insert",
+           "INSERT INTO auditor_denominations "
+           "(denom_pub_hash"
+           ",master_pub"
+           ",valid_from"
+           ",expire_withdraw"
+           ",expire_deposit"
+           ",expire_legal"
+           ",coin_val"
+           ",coin_frac"
+           ",coin_curr"
+           ",fee_withdraw_val"
+           ",fee_withdraw_frac"
+           ",fee_withdraw_curr"
+           ",fee_deposit_val"
+           ",fee_deposit_frac"
+           ",fee_deposit_curr"
+           ",fee_refresh_val"
+           ",fee_refresh_frac"
+           ",fee_refresh_curr"
+           ",fee_refund_val"
+           ",fee_refund_frac"
+           ",fee_refund_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21);",
+           21, NULL);
+
+  /* Used in #postgres_insert_denomination_info() */
+  PREPARE ("auditor_denominations_select",
+           "SELECT"
+           " denom_pub_hash"
+           ",valid_from"
+           ",expire_withdraw"
+           ",expire_deposit"
+           ",expire_legal"
+           ",coin_val"
+           ",coin_frac"
+           ",coin_curr"
+           ",fee_withdraw_val"
+           ",fee_withdraw_frac"
+           ",fee_withdraw_curr"
+           ",fee_deposit_val"
+           ",fee_deposit_frac"
+           ",fee_deposit_curr"
+           ",fee_refresh_val"
+           ",fee_refresh_frac"
+           ",fee_refresh_curr"
+           ",fee_refund_val"
+           ",fee_refund_frac"
+           ",fee_refund_curr"
+           " FROM auditor_denominations"
+           " WHERE master_pub=$1;",
            1, NULL);
+
+  /* Used in #postgres_insert_reserve_info() */
+  PREPARE ("auditor_reserves_insert",
+           "INSERT INTO auditor_reserves "
+	   "(reserve_pub"
+           ",master_pub"
+           ",reserve_balance_val"
+           ",reserve_balance_frac"
+           ",reserve_balance_curr"
+           ",withdraw_fee_balance_val"
+           ",withdraw_fee_balance_frac"
+           ",withdraw_fee_balance_curr"
+           ",expiration_date"
+	   ",last_reserve_in_serial_id"
+           ",last_reserve_out_serial_id"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11);",
+           11, NULL);
+
+  /* Used in #postgres_update_reserve_info() */
+  PREPARE ("auditor_reserves_update",
+           "UPDATE auditor_reserves SET"
+           " reserve_balance_val=$1"
+           ",reserve_balance_frac=$2"
+           ",reserve_balance_curr=$3"
+           ",withdraw_fee_balance_val=$4"
+           ",withdraw_fee_balance_frac=$5"
+           ",withdraw_fee_balance_curr=$6"
+           ",expiration_date=$7"
+	   ",last_reserve_in_serial_id=$8"
+           ",last_reserve_out_serial_id=$9"
+           " WHERE reserve_pub=$10 AND master_pub=$11;",
+           11, NULL);
+
+  /* Used in #postgres_get_reserve_info() */
+  PREPARE ("auditor_reserves_select",
+           "SELECT"
+           " reserve_balance_val"
+           ",reserve_balance_frac"
+           ",reserve_balance_curr"
+           ",withdraw_fee_balance_val"
+           ",withdraw_fee_balance_frac"
+           ",withdraw_fee_balance_curr"
+           ",expiration_date"
+	   ",last_reserve_in_serial_id"
+           ",last_reserve_out_serial_id"
+           " FROM auditor_reserves"
+           " WHERE reserve_pub=$1 AND master_pub=$2;",
+           2, NULL);
+
+  /* Used in #postgres_insert_reserve_summary() */
+  PREPARE ("auditor_reserve_balance_insert",
+           "INSERT INTO auditor_reserve_balance"
+	   "(master_pub"
+	   ",reserve_balance_val"
+           ",reserve_balance_frac"
+           ",reserve_balance_curr"
+           ",withdraw_fee_balance_val"
+           ",withdraw_fee_balance_frac"
+           ",withdraw_fee_balance_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7)",
+           7, NULL);
+
+  /* Used in #postgres_update_reserve_summary() */
+  PREPARE ("auditor_reserve_balance_update",
+           "UPDATE auditor_reserve_balance SET"
+	   " reserve_balance_val=$1"
+           ",reserve_balance_frac=$2"
+           ",reserve_balance_curr=$3"
+           ",withdraw_fee_balance_val=$4"
+           ",withdraw_fee_balance_frac=$5"
+           ",withdraw_fee_balance_curr=$6"
+           " WHERE master_pub=$7;",
+           7, NULL);
+
+  /* Used in #postgres_get_reserve_summary() */
+  PREPARE ("auditor_reserve_balance_select",
+           "SELECT"
+	   " reserve_balance_val"
+           ",reserve_balance_frac"
+           ",reserve_balance_curr"
+           ",withdraw_fee_balance_val"
+           ",withdraw_fee_balance_frac"
+           ",withdraw_fee_balance_curr"
+           " FROM auditor_reserve_balance"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+  /* Used in #postgres_insert_denomination_balance() */
+  PREPARE ("denomination_pending_insert",
+           "INSERT INTO denomination_pending "
+	   "(denom_pub_hash"
+           ",denom_balance_val"
+           ",denom_balance_frac"
+           ",denom_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           ",last_reserve_out_serial_id"
+           ",last_deposit_serial_id"
+	   ",last_melt_serial_id"
+	   ",last_refund_serial_id"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17);",
+           17, NULL);
+
+  /* Used in #postgres_update_denomination_balance() */
+  PREPARE ("denomination_pending_update",
+           "UPDATE denomination_pending SET"
+           " denom_balance_val=$1"
+           ",denom_balance_frac=$2"
+           ",denom_balance_curr=$3"
+           ",deposit_fee_balance_val=$4"
+           ",deposit_fee_balance_frac=$5"
+           ",deposit_fee_balance_curr=$6"
+           ",melt_fee_balance_val=$7"
+           ",melt_fee_balance_frac=$8"
+           ",melt_fee_balance_curr=$9"
+           ",refund_fee_balance_val=$10"
+           ",refund_fee_balance_frac=$11"
+           ",refund_fee_balance_curr=$12"
+           ",last_reserve_out_serial_id=$13"
+           ",last_deposit_serial_id=$14"
+	   ",last_melt_serial_id=$15"
+	   ",last_refund_serial_id=$16"
+           " WHERE denom_pub_hash=$17",
+           18, NULL);
+
+  /* Used in #postgres_get_denomination_balance() */
+  PREPARE ("denomination_pending_select",
+           "SELECT"
+           " denom_balance_val"
+           ",denom_balance_frac"
+           ",denom_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           ",last_reserve_out_serial_id"
+           ",last_deposit_serial_id"
+	   ",last_melt_serial_id"
+	   ",last_refund_serial_id"
+           " FROM denomination_pending"
+           " WHERE denom_pub_hash=$1",
+           1, NULL);
+
+  /* Used in #postgres_insert_denomination_summary() */
+  PREPARE ("total_liabilities_insert",
+           "INSERT INTO total_liabilities "
+	   "(master_pub"
+	   ",denom_balance_val"
+           ",denom_balance_frac"
+           ",denom_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13);",
+           13, NULL);
+
+  /* Used in #postgres_update_denomination_summary() */
+  PREPARE ("total_liabilities_update",
+           "UPDATE total_liabilities SET"
+	   " denom_balance_val=$1"
+           ",denom_balance_frac=$2"
+           ",denom_balance_curr=$3"
+           ",deposit_fee_balance_val=$4"
+           ",deposit_fee_balance_frac=$5"
+           ",deposit_fee_balance_curr=$6"
+           ",melt_fee_balance_val=$7"
+           ",melt_fee_balance_frac=$8"
+           ",melt_fee_balance_curr=$9"
+           ",refund_fee_balance_val=$10"
+           ",refund_fee_balance_frac=$11"
+           ",refund_fee_balance_curr=$12"
+           " WHERE master_pub=$13;",
+           13, NULL);
+
+  /* Used in #postgres_get_denomination_summary() */
+  PREPARE ("total_liabilities_select",
+           "SELECT"
+	   " denom_balance_val"
+           ",denom_balance_frac"
+           ",denom_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           " FROM total_liabilities"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+  /* Used in #postgres_insert_risk_summary() */
+  PREPARE ("total_risk_insert",
+           "INSERT INTO total_risk"
+	   "(master_pub"
+	   ",risk_val"
+           ",risk_frac"
+           ",risk_curr"
+           ") VALUES ($1,$2,$3,$4);",
+           4, NULL);
+
+  /* Used in #postgres_update_risk_summary() */
+  PREPARE ("total_risk_update",
+           "UPDATE total_risk SET "
+	   " risk_val=$1"
+           ",risk_frac=$2"
+           ",risk_curr=$3"
+           " WHERE master_pub=$4;",
+           4, NULL);
+
+  /* Used in #postgres_get_risk_summary() */
+  PREPARE ("total_risk_select",
+           "SELECT"
+	   " risk_val"
+           ",risk_frac"
+           ",risk_curr"
+           " FROM  total_risk"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+
+  /* Used in #postgres_insert_historic_denom_revenue() */
+  PREPARE ("historic_denomination_revenue_insert",
+           "INSERT INTO historic_denomination_revenue"
+	   "(master_pub"
+	   ",denom_pub_hash"
+	   ",revenue_timestamp"
+	   ",revenue_balance_val"
+           ",revenue_balance_frac"
+           ",revenue_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15);",
+           15, NULL);
+
+  /* Used in #postgres_select_historic_denom_revenue() */
+  PREPARE ("historic_denomination_revenue_select",
+           "SELECT"
+	   " denom_pub_hash"
+	   ",revenue_timestamp"
+	   ",revenue_balance_val"
+           ",revenue_balance_frac"
+           ",revenue_balance_curr"
+           ",deposit_fee_balance_val"
+           ",deposit_fee_balance_frac"
+           ",deposit_fee_balance_curr"
+           ",melt_fee_balance_val"
+           ",melt_fee_balance_frac"
+           ",melt_fee_balance_curr"
+           ",refund_fee_balance_val"
+           ",refund_fee_balance_frac"
+           ",refund_fee_balance_curr"
+           " FROM historic_denomination_revenue"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+  /* Used in #postgres_insert_historic_losses() */
+  PREPARE ("historic_losses_insert",
+           "INSERT INTO historic_losses"
+	   "(master_pub"
+	   ",denom_pub_hash"
+	   ",loss_timestamp"
+	   ",loss_balance_val"
+           ",loss_balance_frac"
+           ",loss_balance_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6);",
+           6, NULL);
+
+  /* Used in #postgres_select_historic_losses() */
+  PREPARE ("historic_losses_select",
+           "SELECT"
+	   " denom_pub_hash"
+	   ",loss_timestamp"
+	   ",loss_balance_val"
+           ",loss_balance_frac"
+           ",loss_balance_curr"
+           " FROM historic_losses"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+  /* Used in #postgres_insert_historic_reserve_revenue() */
+  PREPARE ("historic_reserve_summary_insert",
+           "INSERT INTO historic_reserve_summary"
+	   "(master_pub"
+	   ",start_date"
+	   ",end_date"
+	   ",reserve_profits_val"
+           ",reserve_profits_frac"
+           ",reserve_profits_curr"
+           ") VALUES ($1,$2,$3,$4,$5,$6);",
+           6, NULL);
+
+  /* Used in #postgres_select_historic_reserve_revenue() */
+  PREPARE ("historic_reserve_summary_select",
+           "SELECT"
+	   " start_date"
+	   ",end_date"
+	   ",reserve_profits_val"
+           ",reserve_profits_frac"
+           ",reserve_profits_curr"
+           " FROM historic_reserve_summary"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
+  /* Used in #postgres_insert_predicted_result() */
+  PREPARE ("predicted_result_insert",
+           "INSERT INTO predicted_result"
+	   "(master_pub"
+	   ",balance_val"
+           ",balance_frac"
+           ",balance_curr"
+           ") VALUES ($1,$2,$3,$4);",
+           4, NULL);
+
+  /* Used in #postgres_update_predicted_result() */
+  PREPARE ("predicted_result_update",
+           "UPDATE predicted_result SET"
+	   " balance_val=$1"
+           ",balance_frac=$2"
+           ",balance_curr=$3"
+           " WHERE master_pub=$4;",
+           4, NULL);
+
+  /* Used in #postgres_get_predicted_balance() */
+  PREPARE ("predicted_result_select",
+           "SELECT"
+	   " balance_val"
+           ",balance_frac"
+           ",balance_curr"
+           " FROM predicted_result"
+           " WHERE master_pub=$1;",
+           1, NULL);
+
   return GNUNET_OK;
 #undef PREPARE
 }
@@ -743,8 +1149,55 @@ postgres_insert_denomination_info (void *cls,
                                    struct TALER_AUDITORDB_Session *session,
                                    const struct TALER_DenominationKeyValidityPS *issue)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (&issue->denom_hash),
+    GNUNET_PQ_query_param_auto_from_type (&issue->master),
+
+    GNUNET_PQ_query_param_auto_from_type (&issue->start),
+    GNUNET_PQ_query_param_auto_from_type (&issue->expire_withdraw),
+    GNUNET_PQ_query_param_auto_from_type (&issue->expire_deposit),
+    GNUNET_PQ_query_param_auto_from_type (&issue->expire_legal),
+
+    TALER_PQ_query_param_amount_nbo (&issue->value),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_withdraw),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_deposit),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_refresh),
+    TALER_PQ_query_param_amount_nbo (&issue->fee_refund),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  /* check fees match coin currency */
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency_nbo (&issue->value,
+                                                &issue->fee_withdraw));
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency_nbo (&issue->value,
+                                                &issue->fee_deposit));
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency_nbo (&issue->value,
+                                                &issue->fee_refresh));
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency_nbo (&issue->value,
+                                               &issue->fee_refund));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "auditor_denominations_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -762,11 +1215,75 @@ static int
 postgres_select_denomination_info (void *cls,
                                    struct TALER_AUDITORDB_Session *session,
                                    const struct TALER_MasterPublicKeyP *master_pub,
-                                   void *cb, /* FIXME: type! */
+                                   TALER_AUDITORDB_DenominationInfoDataCallback cb,
                                    void *cb_cls)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "auditor_denominations_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int ret = GNUNET_OK;
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_select_denomination_info() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  for (int i = 0; i < nrows; i++)
+  {
+    struct TALER_DenominationKeyValidityPS issue = { .master = *master_pub };
+
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash", &issue.denom_hash),
+
+      GNUNET_PQ_result_spec_auto_from_type ("valid_from", &issue.start),
+      GNUNET_PQ_result_spec_auto_from_type ("expire_withdraw", &issue.expire_withdraw),
+      GNUNET_PQ_result_spec_auto_from_type ("expire_deposit", &issue.expire_deposit),
+      GNUNET_PQ_result_spec_auto_from_type ("expire_legal", &issue.expire_legal),
+
+      TALER_PQ_result_spec_amount_nbo ("coin", &issue.value),
+      TALER_PQ_result_spec_amount_nbo ("fee_withdraw", &issue.fee_withdraw),
+      TALER_PQ_result_spec_amount_nbo ("fee_deposit", &issue.fee_deposit),
+      TALER_PQ_result_spec_amount_nbo ("fee_refresh", &issue.fee_refresh),
+      TALER_PQ_result_spec_amount_nbo ("fee_refund", &issue.fee_refund),
+
+      GNUNET_PQ_result_spec_end
+    };
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (result, rs, 0))
+    {
+      GNUNET_break (0);
+      PQclear (result);
+      return GNUNET_SYSERR;
+    }
+    ret = cb (cb_cls,
+              &issue);
+    switch (ret)
+    {
+    case GNUNET_OK:
+      break;
+
+    default:
+      i = nrows;
+    }
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -799,8 +1316,42 @@ postgres_insert_reserve_info (void *cls,
                               uint64_t last_reserve_in_serial_id,
                               uint64_t last_reserve_out_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (reserve_pub),
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    TALER_PQ_query_param_amount (reserve_balance),
+    TALER_PQ_query_param_amount (withdraw_fee_balance),
+
+    GNUNET_PQ_query_param_auto_from_type (&expiration_date),
+
+    GNUNET_PQ_query_param_uint64 (&last_reserve_in_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_reserve_out_serial_id),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (reserve_balance,
+                                            withdraw_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "auditor_reserves_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -833,8 +1384,42 @@ postgres_update_reserve_info (void *cls,
                               uint64_t last_reserve_in_serial_id,
                               uint64_t last_reserve_out_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    TALER_PQ_query_param_amount (reserve_balance),
+    TALER_PQ_query_param_amount (withdraw_fee_balance),
+
+    GNUNET_PQ_query_param_auto_from_type (&expiration_date),
+
+    GNUNET_PQ_query_param_uint64 (&last_reserve_in_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_reserve_out_serial_id),
+
+    GNUNET_PQ_query_param_auto_from_type (reserve_pub),
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (reserve_balance,
+                                            withdraw_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "auditor_reserves_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -867,8 +1452,59 @@ postgres_get_reserve_info (void *cls,
                            uint64_t *last_reserve_in_serial_id,
                            uint64_t *last_reserve_out_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (reserve_pub),
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "auditor_reserves_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_reserve_info() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("reserve_balance_val", &reserve_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("reserve_balance_frac", &reserve_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("reserve_balance_curr", &reserve_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("withdraw_fee_balance_val", &withdraw_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("withdraw_fee_balance_frac", &withdraw_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("withdraw_fee_balance_curr", &withdraw_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_auto_from_type ("expiration_date", expiration_date),
+
+    GNUNET_PQ_result_spec_uint64 ("last_reserve_in_serial_id", last_reserve_in_serial_id),
+    GNUNET_PQ_result_spec_uint64 ("last_reserve_out_serial_id", last_reserve_out_serial_id),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
@@ -891,8 +1527,36 @@ postgres_insert_reserve_summary (void *cls,
                                  const struct TALER_Amount *reserve_balance,
                                  const struct TALER_Amount *withdraw_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    TALER_PQ_query_param_amount (reserve_balance),
+    TALER_PQ_query_param_amount (withdraw_fee_balance),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (reserve_balance,
+                                            withdraw_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "auditor_reserve_balance_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -915,8 +1579,32 @@ postgres_update_reserve_summary (void *cls,
                                  const struct TALER_Amount *reserve_balance,
                                  const struct TALER_Amount *withdraw_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    TALER_PQ_query_param_amount (reserve_balance),
+    TALER_PQ_query_param_amount (withdraw_fee_balance),
+
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "auditor_reserve_balance_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -939,8 +1627,53 @@ postgres_get_reserve_summary (void *cls,
                               struct TALER_Amount *reserve_balance,
                               struct TALER_Amount *withdraw_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "auditor_reserve_balance_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_reserve_summary() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("reserve_balance_val", &reserve_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("reserve_balance_frac", &reserve_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("reserve_balance_curr", &reserve_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("withdraw_fee_balance_val", &withdraw_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("withdraw_fee_balance_frac", &withdraw_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("withdraw_fee_balance_curr", &withdraw_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
@@ -978,8 +1711,51 @@ postgres_insert_denomination_balance (void *cls,
                                       uint64_t last_melt_serial_id,
                                       uint64_t last_refund_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
+
+    TALER_PQ_query_param_amount (denom_balance),
+    TALER_PQ_query_param_amount (deposit_fee_balance),
+    TALER_PQ_query_param_amount (melt_fee_balance),
+    TALER_PQ_query_param_amount (refund_fee_balance),
+
+    GNUNET_PQ_query_param_uint64 (&last_reserve_out_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_deposit_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_melt_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_refund_serial_id),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            deposit_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            melt_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            refund_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "denomination_pending_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1017,8 +1793,39 @@ postgres_update_denomination_balance (void *cls,
                                       uint64_t last_melt_serial_id,
                                       uint64_t last_refund_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    TALER_PQ_query_param_amount (denom_balance),
+    TALER_PQ_query_param_amount (deposit_fee_balance),
+    TALER_PQ_query_param_amount (melt_fee_balance),
+    TALER_PQ_query_param_amount (refund_fee_balance),
+
+    GNUNET_PQ_query_param_uint64 (&last_reserve_out_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_deposit_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_melt_serial_id),
+    GNUNET_PQ_query_param_uint64 (&last_refund_serial_id),
+
+    GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "denomination_pending_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1055,8 +1862,66 @@ postgres_get_denomination_balance (void *cls,
                                    uint64_t *last_melt_serial_id,
                                    uint64_t *last_refund_serial_id)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "denomination_pending_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_denomination_balance() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("denom_balance_val", &denom_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("denom_balance_frac", &denom_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("denom_balance_curr", &denom_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("deposit_fee_balance_val", &deposit_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("deposit_fee_balance_frac", &deposit_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("deposit_fee_balance_curr", &deposit_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("melt_fee_balance_val", &melt_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("melt_fee_balance_frac", &melt_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("melt_fee_balance_curr", &melt_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("refund_fee_balance_val", &refund_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("refund_fee_balance_frac", &refund_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("refund_fee_balance_curr", &refund_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("last_reserve_out_serial_id", last_reserve_out_serial_id),
+    GNUNET_PQ_result_spec_uint64 ("last_deposit_serial_id", last_deposit_serial_id),
+    GNUNET_PQ_result_spec_uint64 ("last_melt_serial_id", last_melt_serial_id),
+    GNUNET_PQ_result_spec_uint64 ("last_refund_serial_id", last_refund_serial_id),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
@@ -1082,8 +1947,46 @@ postgres_insert_denomination_summary (void *cls,
                                       const struct TALER_Amount *melt_fee_balance,
                                       const struct TALER_Amount *refund_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    TALER_PQ_query_param_amount (denom_balance),
+    TALER_PQ_query_param_amount (deposit_fee_balance),
+    TALER_PQ_query_param_amount (melt_fee_balance),
+    TALER_PQ_query_param_amount (refund_fee_balance),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            deposit_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            melt_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (denom_balance,
+                                            refund_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "total_liabilities_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1109,8 +2012,34 @@ postgres_update_denomination_summary (void *cls,
                                       const struct TALER_Amount *melt_fee_balance,
                                       const struct TALER_Amount *refund_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    TALER_PQ_query_param_amount (denom_balance),
+    TALER_PQ_query_param_amount (deposit_fee_balance),
+    TALER_PQ_query_param_amount (melt_fee_balance),
+    TALER_PQ_query_param_amount (refund_fee_balance),
+
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "total_liabilities_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1136,8 +2065,61 @@ postgres_get_denomination_summary (void *cls,
                                    struct TALER_Amount *melt_fee_balance,
                                    struct TALER_Amount *refund_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "total_liabilities_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_denomination_summary() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("denom_balance_val", &denom_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("denom_balance_frac", &denom_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("denom_balance_curr", &denom_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("deposit_fee_balance_val", &deposit_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("deposit_fee_balance_frac", &deposit_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("deposit_fee_balance_curr", &deposit_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("melt_fee_balance_val", &melt_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("melt_fee_balance_frac", &melt_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("melt_fee_balance_curr", &melt_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_uint64 ("refund_fee_balance_val", &refund_fee_balance->value),
+    GNUNET_PQ_result_spec_uint32 ("refund_fee_balance_frac", &refund_fee_balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("refund_fee_balance_curr", &refund_fee_balance->currency),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
@@ -1157,8 +2139,31 @@ postgres_insert_risk_summary (void *cls,
                               const struct TALER_MasterPublicKeyP *master_pub,
                               const struct TALER_Amount *risk)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    TALER_PQ_query_param_amount (risk),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "total_risk_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1178,8 +2183,31 @@ postgres_update_risk_summary (void *cls,
                               const struct TALER_MasterPublicKeyP *master_pub,
                               const struct TALER_Amount *risk)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    TALER_PQ_query_param_amount (risk),
+
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "total_risk_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1199,8 +2227,49 @@ postgres_get_risk_summary (void *cls,
                            const struct TALER_MasterPublicKeyP *master_pub,
                            struct TALER_Amount *risk)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "total_risk_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_risk_summary() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("risk_val", &risk->value),
+    GNUNET_PQ_result_spec_uint32 ("risk_frac", &risk->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("risk_curr", &risk->currency),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
@@ -1232,8 +2301,49 @@ postgres_insert_historic_denom_revenue (void *cls,
                                         const struct TALER_Amount *melt_fee_balance,
                                         const struct TALER_Amount *refund_fee_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+    GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
+
+    GNUNET_PQ_query_param_auto_from_type (&revenue_timestamp),
+
+    TALER_PQ_query_param_amount (revenue_balance),
+    TALER_PQ_query_param_amount (deposit_fee_balance),
+    TALER_PQ_query_param_amount (melt_fee_balance),
+    TALER_PQ_query_param_amount (refund_fee_balance),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (revenue_balance,
+                                            deposit_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (revenue_balance,
+                                            melt_fee_balance));
+
+  GNUNET_assert (GNUNET_YES ==
+                 TALER_amount_cmp_currency (revenue_balance,
+                                            refund_fee_balance));
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "historic_denomination_revenue_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1252,11 +2362,82 @@ static int
 postgres_select_historic_denom_revenue (void *cls,
                                         struct TALER_AUDITORDB_Session *session,
                                         const struct TALER_MasterPublicKeyP *master_pub,
-                                        void *cb, /* FIXME: fix type */
+                                        TALER_AUDITORDB_HistoricDenominationRevenueDataCallback cb,
                                         void *cb_cls)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "historic_denomination_revenue_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int ret = GNUNET_OK;
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_select_historic_denom_revenue() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  for (int i = 0; i < nrows; i++)
+  {
+    struct GNUNET_HashCode denom_pub_hash;
+    struct GNUNET_TIME_Absolute revenue_timestamp;
+    struct TALER_Amount revenue_balance;
+    struct TALER_Amount deposit_fee_balance;
+    struct TALER_Amount melt_fee_balance;
+    struct TALER_Amount refund_fee_balance;
+
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash", &denom_pub_hash),
+
+      GNUNET_PQ_result_spec_auto_from_type ("revenue_timestamp", &revenue_timestamp),
+
+      TALER_PQ_result_spec_amount ("revenue_balance", &revenue_balance),
+      TALER_PQ_result_spec_amount ("deposit_fee_balance", &deposit_fee_balance),
+      TALER_PQ_result_spec_amount ("melt_fee_balance", &melt_fee_balance),
+      TALER_PQ_result_spec_amount ("refund_fee_balance", &refund_fee_balance),
+
+      GNUNET_PQ_result_spec_end
+    };
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (result, rs, 0))
+    {
+      GNUNET_break (0);
+      PQclear (result);
+      return GNUNET_SYSERR;
+    }
+
+    ret = cb (cb_cls,
+              &denom_pub_hash,
+              revenue_timestamp,
+              &revenue_balance,
+              &deposit_fee_balance,
+              &melt_fee_balance,
+              &refund_fee_balance);
+    switch (ret)
+    {
+    case GNUNET_OK:
+      break;
+
+    default:
+      i = nrows;
+    }
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1283,8 +2464,34 @@ postgres_insert_historic_losses (void *cls,
                                  struct GNUNET_TIME_Absolute loss_timestamp,
                                  const struct TALER_Amount *loss_balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+    GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
+
+    GNUNET_PQ_query_param_auto_from_type (&loss_timestamp),
+
+    TALER_PQ_query_param_amount (loss_balance),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "historic_losses_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1303,11 +2510,72 @@ static int
 postgres_select_historic_losses (void *cls,
                                  struct TALER_AUDITORDB_Session *session,
                                  const struct TALER_MasterPublicKeyP *master_pub,
-                                 void *cb, /* FIXME: fix type */
+                                 TALER_AUDITORDB_HistoricLossesDataCallback cb,
                                  void *cb_cls)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "historic_losses_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int ret = GNUNET_OK;
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_select_historic_losses() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  for (int i = 0; i < nrows; i++)
+  {
+    struct GNUNET_HashCode denom_pub_hash;
+    struct GNUNET_TIME_Absolute loss_timestamp;
+    struct TALER_Amount loss_balance;
+
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash", &denom_pub_hash),
+
+      GNUNET_PQ_result_spec_auto_from_type ("loss_timestamp", &loss_timestamp),
+
+      TALER_PQ_result_spec_amount ("loss_balance", &loss_balance),
+
+      GNUNET_PQ_result_spec_end
+    };
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (result, rs, 0))
+    {
+      GNUNET_break (0);
+      PQclear (result);
+      return GNUNET_SYSERR;
+    }
+    ret = cb (cb_cls,
+              &denom_pub_hash,
+              loss_timestamp,
+              &loss_balance);
+    switch (ret)
+    {
+    case GNUNET_OK:
+      break;
+
+    default:
+      i = nrows;
+    }
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1330,8 +2598,34 @@ postgres_insert_historic_reserve_revenue (void *cls,
                                           struct GNUNET_TIME_Absolute end_time,
                                           const struct TALER_Amount *reserve_profits)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_auto_from_type (&start_time),
+    GNUNET_PQ_query_param_auto_from_type (&end_time),
+
+    TALER_PQ_query_param_amount (reserve_profits),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "historic_reserve_summary_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1349,11 +2643,71 @@ static int
 postgres_select_historic_reserve_revenue (void *cls,
                                           struct TALER_AUDITORDB_Session *session,
                                           const struct TALER_MasterPublicKeyP *master_pub,
-                                          void *cb, /* FIXME: type */
+                                          TALER_AUDITORDB_HistoricReserveRevenueDataCallback cb,
                                           void *cb_cls)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "historic_reserve_summary_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int ret = GNUNET_OK;
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_select_historic_reserve_revenue() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  for (int i = 0; i < nrows; i++)
+  {
+    struct GNUNET_TIME_Absolute start_time;
+    struct GNUNET_TIME_Absolute end_time;
+    struct TALER_Amount reserve_profits;
+
+    struct GNUNET_PQ_ResultSpec rs[] = {
+      GNUNET_PQ_result_spec_auto_from_type ("start_time", &start_time),
+      GNUNET_PQ_result_spec_auto_from_type ("end_time", &end_time),
+
+      TALER_PQ_result_spec_amount ("reserve_profits", &reserve_profits),
+
+      GNUNET_PQ_result_spec_end
+    };
+    if (GNUNET_OK !=
+        GNUNET_PQ_extract_result (result, rs, 0))
+    {
+      GNUNET_break (0);
+      PQclear (result);
+      return GNUNET_SYSERR;
+    }
+    ret = cb (cb_cls,
+              start_time,
+              end_time,
+              &reserve_profits);
+    switch (ret)
+    {
+    case GNUNET_OK:
+      break;
+
+    default:
+      i = nrows;
+    }
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1373,8 +2727,31 @@ postgres_insert_predicted_result (void *cls,
                                   const struct TALER_MasterPublicKeyP *master_pub,
                                   const struct TALER_Amount *balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    TALER_PQ_query_param_amount (balance),
+
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "predicted_result_insert",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1394,8 +2771,27 @@ postgres_update_predicted_result (void *cls,
                                   const struct TALER_MasterPublicKeyP *master_pub,
                                   const struct TALER_Amount *balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  PGresult *result;
+  int ret;
+
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_end
+  };
+
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                   "predicted_result_update",
+                                   params);
+  if (PGRES_COMMAND_OK != PQresultStatus (result))
+  {
+    ret = GNUNET_SYSERR;
+    BREAK_DB_ERR (result);
+  }
+  else
+  {
+    ret = GNUNET_OK;
+  }
+  PQclear (result);
+  return ret;
 }
 
 
@@ -1415,8 +2811,49 @@ postgres_get_predicted_balance (void *cls,
                                 const struct TALER_MasterPublicKeyP *master_pub,
                                 struct TALER_Amount *balance)
 {
-  GNUNET_break (0); // FIXME: not implemented
-  return GNUNET_SYSERR;
+  struct GNUNET_PQ_QueryParam params[] = {
+    GNUNET_PQ_query_param_auto_from_type (master_pub),
+
+    GNUNET_PQ_query_param_end
+  };
+  PGresult *result;
+  result = GNUNET_PQ_exec_prepared (session->conn,
+                                    "predicted_result_select",
+                                    params);
+  if (PGRES_TUPLES_OK !=
+      PQresultStatus (result))
+  {
+    BREAK_DB_ERR (result);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+
+  int nrows = PQntuples (result);
+  if (0 == nrows)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "postgres_get_predicted_balance() returned 0 matching rows\n");
+    PQclear (result);
+    return GNUNET_NO;
+  }
+  GNUNET_assert (1 == nrows);
+
+  struct GNUNET_PQ_ResultSpec rs[] = {
+    GNUNET_PQ_result_spec_uint64 ("balance_val", &balance->value),
+    GNUNET_PQ_result_spec_uint32 ("balance_frac", &balance->fraction),
+    GNUNET_PQ_result_spec_auto_from_type ("balance_curr", &balance->currency),
+
+    GNUNET_PQ_result_spec_end
+  };
+  if (GNUNET_OK !=
+      GNUNET_PQ_extract_result (result, rs, 0))
+  {
+    GNUNET_break (0);
+    PQclear (result);
+    return GNUNET_SYSERR;
+  }
+  PQclear (result);
+  return GNUNET_OK;
 }
 
 
diff --git a/src/auditordb/test-auditor-db-postgres.conf b/src/auditordb/test-auditor-db-postgres.conf
new file mode 100644
index 000000000..5c1e7fbc1
--- /dev/null
+++ b/src/auditordb/test-auditor-db-postgres.conf
@@ -0,0 +1,7 @@
+[auditor]
+# Which database backend do we use for the auditor?
+DB = postgres
+
+[auditordb-postgres]
+# Argument for Postgres for how to connect to the database.
+DB_CONN_STR = "postgres:///talercheck"
diff --git a/src/auditordb/test_auditordb.c b/src/auditordb/test_auditordb.c
new file mode 100644
index 000000000..fc7cf522e
--- /dev/null
+++ b/src/auditordb/test_auditordb.c
@@ -0,0 +1,253 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2014, 2015, 2016 GNUnet e.V.
+
+  TALER is free software; you can redistribute it and/or modify it under the
+  terms of the GNU General Public License as published by the Free Software
+  Foundation; either version 3, or (at your option) any later version.
+
+  TALER is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License along with
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+/**
+ * @file auditordb/test_auditordb.c
+ * @brief test cases for DB interaction functions
+ * @author Sree Harsha Totakura
+ * @author Christian Grothoff
+ * @author Marcello Stanisci
+ */
+#include "platform.h"
+#include "taler_auditordb_lib.h"
+#include "taler_auditordb_plugin.h"
+
+
+/**
+ * Global result from the testcase.
+ */
+static int result = -1;
+
+/**
+ * Report line of error if @a cond is true, and jump to label "drop".
+ */
+#define FAILIF(cond)                              \
+  do {                                          \
+    if (!(cond)){ break;}                      \
+    GNUNET_break (0);                           \
+    /*goto drop;*/                              \
+  } while (0)
+
+
+/**
+ * Initializes @a ptr with random data.
+ */
+#define RND_BLK(ptr)                                                    \
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, ptr, sizeof (*ptr))
+
+/**
+ * Initializes @a ptr with zeros.
+ */
+#define ZR_BLK(ptr) \
+  memset (ptr, 0, sizeof (*ptr))
+
+
+/**
+ * Currency we use.
+ */
+#define CURRENCY "EUR"
+
+/**
+ * Database plugin under test.
+ */
+static struct TALER_AUDITORDB_Plugin *plugin;
+
+
+/**
+ * Callback that should never be called.
+ */
+static void
+dead_prepare_cb (void *cls,
+                 unsigned long long rowid,
+                 const char *wire_method,
+                 const char *buf,
+                 size_t buf_size)
+{
+  GNUNET_assert (0);
+}
+
+
+int
+select_denomination_info_result (void *cls,
+                                 const struct TALER_DenominationKeyValidityPS *issue2)
+{
+  const struct TALER_DenominationKeyValidityPS *issue1 = cls;
+
+  if (0 != memcmp (issue1, issue2, sizeof (*issue2)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "select_denomination_info_result: issue does not match\n");
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure with config
+ */
+static void
+run (void *cls)
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct TALER_AUDITORDB_Session *session;
+
+  if (NULL ==
+      (plugin = TALER_AUDITORDB_plugin_load (cfg)))
+  {
+    result = 77;
+    return;
+  }
+
+  (void) plugin->drop_tables (plugin->cls);
+  if (GNUNET_OK !=
+      plugin->create_tables (plugin->cls))
+  {
+    result = 77;
+    goto drop;
+  }
+  if (NULL ==
+      (session = plugin->get_session (plugin->cls)))
+  {
+    result = 77;
+    goto drop;
+  }
+
+  struct TALER_Amount value, fee_withdraw, fee_deposit, fee_refresh, fee_refund;
+
+  GNUNET_assert (GNUNET_OK ==
+                 TALER_string_to_amount (CURRENCY ":1.000010",
+                                         &value));
+  GNUNET_assert (GNUNET_OK ==
+                 TALER_string_to_amount (CURRENCY ":0.000011",
+                                         &fee_withdraw));
+  GNUNET_assert (GNUNET_OK ==
+                 TALER_string_to_amount (CURRENCY ":0.000012",
+                                         &fee_deposit));
+  GNUNET_assert (GNUNET_OK ==
+                 TALER_string_to_amount (CURRENCY ":0.000013",
+                                         &fee_refresh));
+  GNUNET_assert (GNUNET_OK ==
+                 TALER_string_to_amount (CURRENCY ":0.000014",
+                                         &fee_refund));
+
+  struct TALER_MasterPublicKeyP master_pub;
+  struct TALER_ReservePublicKeyP reserve_pub;
+  RND_BLK (&master_pub);
+  RND_BLK (&reserve_pub);
+
+  struct TALER_DenominationPrivateKey denom_priv;
+  struct TALER_DenominationPublicKey denom_pub;
+  struct GNUNET_HashCode denom_pub_hash;
+  denom_priv.rsa_private_key = GNUNET_CRYPTO_rsa_private_key_create (1024);
+  denom_pub.rsa_public_key = GNUNET_CRYPTO_rsa_private_key_get_public (denom_priv.rsa_private_key);
+  GNUNET_CRYPTO_rsa_public_key_hash (denom_pub.rsa_public_key, &denom_pub_hash);
+
+  struct GNUNET_TIME_Absolute now, past, future;
+  now = GNUNET_TIME_absolute_get ();
+  past = GNUNET_TIME_absolute_subtract (now,
+                                        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS,
+                                                                       4));
+  future = GNUNET_TIME_absolute_add (now,
+                                     GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS,
+                                                                  4));
+
+  struct TALER_DenominationKeyValidityPS issue = { 0 };
+  issue.master = master_pub;
+  issue.denom_hash = denom_pub_hash;
+
+  issue.start = GNUNET_TIME_absolute_hton (now);
+  issue.expire_withdraw = GNUNET_TIME_absolute_hton
+    (GNUNET_TIME_absolute_add (now,
+                               GNUNET_TIME_UNIT_HOURS));
+  issue.expire_deposit = GNUNET_TIME_absolute_hton
+      (GNUNET_TIME_absolute_add
+       (now,
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 2)));
+  issue.expire_legal = GNUNET_TIME_absolute_hton
+      (GNUNET_TIME_absolute_add
+       (now,
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 3)));
+  TALER_amount_hton (&issue.value, &value);
+  TALER_amount_hton (&issue.fee_withdraw, &fee_withdraw);
+  TALER_amount_hton (&issue.fee_deposit, &fee_deposit);
+  TALER_amount_hton (&issue.fee_refresh, &fee_refresh);
+  TALER_amount_hton (&issue.fee_refund, &fee_refund);
+
+  FAILIF (GNUNET_OK !=
+          plugin->insert_denomination_info (plugin->cls,
+                                            session,
+                                            &issue));
+
+  FAILIF (GNUNET_OK !=
+          plugin->select_denomination_info (plugin->cls,
+                                            session,
+                                            &master_pub,
+                                            select_denomination_info_result,
+                                            &issue));
+
+  result = 0;
+
+drop:
+
+  GNUNET_break (GNUNET_OK ==
+                plugin->drop_tables (plugin->cls));
+  TALER_AUDITORDB_plugin_unload (plugin);
+  plugin = NULL;
+}
+
+
+int
+main (int argc,
+      char *const argv[])
+{
+  const char *plugin_name;
+  char *config_filename;
+  char *testname;
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  result = -1;
+  if (NULL == (plugin_name = strrchr (argv[0], (int) '-')))
+  {
+    GNUNET_break (0);
+    return -1;
+  }
+  GNUNET_log_setup (argv[0],
+                    "WARNING",
+                    NULL);
+  plugin_name++;
+  (void) GNUNET_asprintf (&testname,
+                          "test-auditor-db-%s", plugin_name);
+  (void) GNUNET_asprintf (&config_filename,
+                          "%s.conf", testname);
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_parse (cfg,
+                                  config_filename))
+  {
+    GNUNET_break (0);
+    GNUNET_free (config_filename);
+    GNUNET_free (testname);
+    return 2;
+  }
+  GNUNET_SCHEDULER_run (&run, cfg);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_free (config_filename);
+  GNUNET_free (testname);
+  return result;
+}
diff --git a/src/include/taler_auditordb_plugin.h b/src/include/taler_auditordb_plugin.h
index cc75fb014..6bfae25cc 100644
--- a/src/include/taler_auditordb_plugin.h
+++ b/src/include/taler_auditordb_plugin.h
@@ -29,6 +29,90 @@
 
 
 /**
+ * Function called with the results of select_denomination_info()
+ *
+ * @param cls closure
+ * @param issue issuing information with value, fees and other info about the denomination.
+ *
+ * @return sets the return value of select_denomination_info(),
+ *         #GNUNET_OK to continue,
+ *         #GNUNET_NO to stop processing further rows
+ *         #GNUNET_SYSERR or other values on error.
+ */
+typedef int
+(*TALER_AUDITORDB_DenominationInfoDataCallback)(void *cls,
+                                                const struct TALER_DenominationKeyValidityPS *issue);
+
+
+/**
+ * Function called with the results of select_historic_denom_revenue()
+ *
+ * @param cls closure
+ * @param denom_pub_hash hash of the denomination key
+ * @param revenue_timestamp when did this profit get realized
+ * @param revenue_balance what was the total profit made from
+ *                        deposit fees, melting fees, refresh fees
+ *                        and coins that were never returned?
+ * @param deposit_fee_balance total profits from deposit fees
+ * @param melt_fee_balance total profits from melting fees
+ * @param refund_fee_balance total profits from refund fees
+ *
+ * @return sets the return value of select_denomination_info(),
+ *         #GNUNET_OK to continue,
+ *         #GNUNET_NO to stop processing further rows
+ *         #GNUNET_SYSERR or other values on error.
+ */
+typedef int
+(*TALER_AUDITORDB_HistoricDenominationRevenueDataCallback)(void *cls,
+                                                           const struct GNUNET_HashCode *denom_pub_hash,
+                                                           struct GNUNET_TIME_Absolute revenue_timestamp,
+                                                           const struct TALER_Amount *revenue_balance,
+                                                           const struct TALER_Amount *deposit_fee_balance,
+                                                           const struct TALER_Amount *melt_fee_balance,
+                                                           const struct TALER_Amount *refund_fee_balance);
+
+
+/**
+ * Function called with the results of select_historic_losses()
+ *
+ * @param cls closure
+ * @param denom_pub_hash hash of the denomination key
+ * @param loss_timestamp when did this profit get realized
+ * @param loss_balance what was the total loss
+ *
+ * @return sets the return value of select_denomination_info(),
+ *         #GNUNET_OK to continue,
+ *         #GNUNET_NO to stop processing further rows
+ *         #GNUNET_SYSERR or other values on error.
+ */
+typedef int
+(*TALER_AUDITORDB_HistoricLossesDataCallback)(void *cls,
+                                              const struct GNUNET_HashCode *denom_pub_hash,
+                                              struct GNUNET_TIME_Absolute loss_timestamp,
+                                              const struct TALER_Amount *loss_balance);
+
+
+/**
+ * Function called with the results of select_historic_reserve_revenue()
+ *
+ * @param cls closure
+ * @param start_time beginning of aggregated time interval
+ * @param end_time end of aggregated time interval
+ * @param reserve_profits total profits made
+ *
+ * @return sets the return value of select_denomination_info(),
+ *         #GNUNET_OK to continue,
+ *         #GNUNET_NO to stop processing further rows
+ *         #GNUNET_SYSERR or other values on error.
+ */
+typedef int
+(*TALER_AUDITORDB_HistoricReserveRevenueDataCallback)(void *cls,
+                                                      struct GNUNET_TIME_Absolute start_time,
+                                                      struct GNUNET_TIME_Absolute end_time,
+                                                      const struct TALER_Amount *reserve_profits);
+
+
+/**
  * Handle for one session with the database.
  */
 struct TALER_AUDITORDB_Session;
@@ -164,7 +248,7 @@ struct TALER_AUDITORDB_Plugin
   (*select_denomination_info)(void *cls,
                               struct TALER_AUDITORDB_Session *session,
                               const struct TALER_MasterPublicKeyP *master_pub,
-                              void *cb, /* FIXME: type! */
+                              TALER_AUDITORDB_DenominationInfoDataCallback cb,
                               void *cb_cls);
 
 
@@ -586,7 +670,7 @@ struct TALER_AUDITORDB_Plugin
   (*select_historic_denom_revenue)(void *cls,
                                    struct TALER_AUDITORDB_Session *session,
                                    const struct TALER_MasterPublicKeyP *master_pub,
-                                   void *cb, /* FIXME: fix type */
+                                   TALER_AUDITORDB_HistoricDenominationRevenueDataCallback cb,
                                    void *cb_cls);
 
 
@@ -628,7 +712,7 @@ struct TALER_AUDITORDB_Plugin
   (*select_historic_losses)(void *cls,
                             struct TALER_AUDITORDB_Session *session,
                             const struct TALER_MasterPublicKeyP *master_pub,
-                            void *cb, /* FIXME: fix type */
+                            TALER_AUDITORDB_HistoricLossesDataCallback cb,
                             void *cb_cls);
 
 
@@ -666,7 +750,7 @@ struct TALER_AUDITORDB_Plugin
   (*select_historic_reserve_revenue)(void *cls,
                                      struct TALER_AUDITORDB_Session *session,
                                      const struct TALER_MasterPublicKeyP *master_pub,
-                                     void *cb, /* FIXME: type */
+                                     TALER_AUDITORDB_HistoricReserveRevenueDataCallback cb,
                                      void *cb_cls);