exchange

Base system with REST service to issue digital coins, run by the payment service provider
Log | Files | Refs | Submodules | README | LICENSE

iterate_records_by_table.c (114013B)


      1 /*
      2    This file is part of GNUnet
      3    Copyright (C) 2020-2025 Taler Systems SA
      4 
      5    GNUnet is free software: you can redistribute it and/or modify it
      6    under the terms of the GNU Affero General Public License as published
      7    by the Free Software Foundation, either version 3 of the License,
      8    or (at your option) any later version.
      9 
     10    GNUnet is distributed in the hope that it will be useful, but
     11    WITHOUT ANY WARRANTY; without even the implied warranty of
     12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13    Affero General Public License for more details.
     14 
     15    You should have received a copy of the GNU Affero General Public License
     16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
     17 
     18      SPDX-License-Identifier: AGPL3.0-or-later
     19  */
     20 /**
     21  * @file exchangedb/iterate_records_by_table.c
     22  * @brief implementation of lookup_records_by_table
     23  * @author Christian Grothoff
     24  * @author Özgür Kesim
     25  */
     26 #include "taler/taler_error_codes.h"
     27 #include "taler/taler_dbevents.h"
     28 #include "taler/taler_pq_lib.h"
     29 #include "exchange-database/iterate_records_by_table.h"
     30 #include "helper.h"
     31 #include <gnunet/gnunet_pq_lib.h>
     32 
     33 
     34 /**
     35  * Closure for callbacks used by #postgres_lookup_records_by_table.
     36  */
     37 struct LookupRecordsByTableContext
     38 {
     39   /**
     40    * Plugin context.
     41    */
     42   struct TALER_EXCHANGEDB_PostgresContext *pg;
     43 
     44   /**
     45    * Function to call with the results.
     46    */
     47   TALER_EXCHANGEDB_ReplicationCallback cb;
     48 
     49   /**
     50    * Closure for @a cb.
     51    */
     52   void *cb_cls;
     53 
     54   /**
     55    * Set to true on errors.
     56    */
     57   bool error;
     58 };
     59 
     60 
     61 /**
     62  * Function called with denominations table entries.
     63  *
     64  * @param cls closure
     65  * @param result the postgres result
     66  * @param num_results the number of results in @a result
     67  */
     68 static void
     69 lrbt_cb_table_denominations (void *cls,
     70                              PGresult *result,
     71                              unsigned int num_results)
     72 {
     73   struct LookupRecordsByTableContext *ctx = cls;
     74   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
     75   struct TALER_EXCHANGEDB_TableData td = {
     76     .table = TALER_EXCHANGEDB_RT_DENOMINATIONS
     77   };
     78 
     79   for (unsigned int i = 0; i<num_results; i++)
     80   {
     81     struct GNUNET_PQ_ResultSpec rs[] = {
     82       GNUNET_PQ_result_spec_uint64 (
     83         "serial",
     84         &td.serial),
     85       GNUNET_PQ_result_spec_uint32 (
     86         "denom_type",
     87         &td.details.denominations.denom_type),
     88       GNUNET_PQ_result_spec_uint32 (
     89         "age_mask",
     90         &td.details.denominations.age_mask),
     91       TALER_PQ_result_spec_denom_pub (
     92         "denom_pub",
     93         &td.details.denominations.denom_pub),
     94       GNUNET_PQ_result_spec_auto_from_type (
     95         "master_sig",
     96         &td.details.denominations.master_sig),
     97       GNUNET_PQ_result_spec_timestamp (
     98         "valid_from",
     99         &td.details.denominations.valid_from),
    100       GNUNET_PQ_result_spec_timestamp (
    101         "expire_withdraw",
    102         &td.details.denominations.
    103         expire_withdraw),
    104       GNUNET_PQ_result_spec_timestamp (
    105         "expire_deposit",
    106         &td.details.denominations.
    107         expire_deposit),
    108       GNUNET_PQ_result_spec_timestamp (
    109         "expire_legal",
    110         &td.details.denominations.expire_legal),
    111       TALER_PQ_RESULT_SPEC_AMOUNT (
    112         "coin",
    113         &td.details.denominations.coin),
    114       TALER_PQ_RESULT_SPEC_AMOUNT (
    115         "fee_withdraw",
    116         &td.details.denominations.fees.withdraw),
    117       TALER_PQ_RESULT_SPEC_AMOUNT (
    118         "fee_deposit",
    119         &td.details.denominations.fees.deposit),
    120       TALER_PQ_RESULT_SPEC_AMOUNT (
    121         "fee_refresh",
    122         &td.details.denominations.fees.refresh),
    123       TALER_PQ_RESULT_SPEC_AMOUNT (
    124         "fee_refund",
    125         &td.details.denominations.fees.refund),
    126       GNUNET_PQ_result_spec_end
    127     };
    128 
    129     if (GNUNET_OK !=
    130         GNUNET_PQ_extract_result (result,
    131                                   rs,
    132                                   i))
    133     {
    134       GNUNET_break (0);
    135       ctx->error = true;
    136       return;
    137     }
    138     ctx->cb (ctx->cb_cls,
    139              &td);
    140     GNUNET_PQ_cleanup_result (rs);
    141   }
    142 }
    143 
    144 
    145 /**
    146  * Function called with denomination_revocations table entries.
    147  *
    148  * @param cls closure
    149  * @param result the postgres result
    150  * @param num_results the number of results in @a result
    151  */
    152 static void
    153 lrbt_cb_table_denomination_revocations (void *cls,
    154                                         PGresult *result,
    155                                         unsigned int num_results)
    156 {
    157   struct LookupRecordsByTableContext *ctx = cls;
    158   struct TALER_EXCHANGEDB_TableData td = {
    159     .table = TALER_EXCHANGEDB_RT_DENOMINATION_REVOCATIONS
    160   };
    161 
    162   for (unsigned int i = 0; i<num_results; i++)
    163   {
    164     struct GNUNET_PQ_ResultSpec rs[] = {
    165       GNUNET_PQ_result_spec_uint64 ("serial",
    166                                     &td.serial),
    167       GNUNET_PQ_result_spec_uint64 (
    168         "denominations_serial",
    169         &td.details.denomination_revocations.denominations_serial),
    170       GNUNET_PQ_result_spec_auto_from_type (
    171         "master_sig",
    172         &td.details.denomination_revocations.master_sig),
    173       GNUNET_PQ_result_spec_end
    174     };
    175 
    176     if (GNUNET_OK !=
    177         GNUNET_PQ_extract_result (result,
    178                                   rs,
    179                                   i))
    180     {
    181       GNUNET_break (0);
    182       ctx->error = true;
    183       return;
    184     }
    185     ctx->cb (ctx->cb_cls,
    186              &td);
    187     GNUNET_PQ_cleanup_result (rs);
    188   }
    189 }
    190 
    191 
    192 /**
    193  * Function called with wire_targets table entries.
    194  *
    195  * @param cls closure
    196  * @param result the postgres result
    197  * @param num_results the number of results in @a result
    198  */
    199 static void
    200 lrbt_cb_table_wire_targets (void *cls,
    201                             PGresult *result,
    202                             unsigned int num_results)
    203 {
    204   struct LookupRecordsByTableContext *ctx = cls;
    205   struct TALER_EXCHANGEDB_TableData td = {
    206     .table = TALER_EXCHANGEDB_RT_WIRE_TARGETS
    207   };
    208 
    209   for (unsigned int i = 0; i<num_results; i++)
    210   {
    211     struct GNUNET_PQ_ResultSpec rs[] = {
    212       GNUNET_PQ_result_spec_uint64 (
    213         "serial",
    214         &td.serial),
    215       GNUNET_PQ_result_spec_string (
    216         "payto_uri",
    217         &td.details.wire_targets.full_payto_uri.full_payto),
    218       GNUNET_PQ_result_spec_end
    219     };
    220 
    221     if (GNUNET_OK !=
    222         GNUNET_PQ_extract_result (result,
    223                                   rs,
    224                                   i))
    225     {
    226       GNUNET_break (0);
    227       ctx->error = true;
    228       return;
    229     }
    230     ctx->cb (ctx->cb_cls,
    231              &td);
    232     GNUNET_PQ_cleanup_result (rs);
    233   }
    234 }
    235 
    236 
    237 /**
    238  * Function called with wire_targets table entries.
    239  *
    240  * @param cls closure
    241  * @param result the postgres result
    242  * @param num_results the number of results in @a result
    243  */
    244 static void
    245 lrbt_cb_table_kyc_targets (void *cls,
    246                            PGresult *result,
    247                            unsigned int num_results)
    248 {
    249   struct LookupRecordsByTableContext *ctx = cls;
    250   struct TALER_EXCHANGEDB_TableData td = {
    251     .table = TALER_EXCHANGEDB_RT_KYC_TARGETS
    252   };
    253 
    254   for (unsigned int i = 0; i<num_results; i++)
    255   {
    256     struct GNUNET_PQ_ResultSpec rs[] = {
    257       GNUNET_PQ_result_spec_uint64 (
    258         "serial",
    259         &td.serial),
    260       GNUNET_PQ_result_spec_auto_from_type (
    261         "h_normalized_payto",
    262         &td.details.kyc_targets.h_normalized_payto),
    263       GNUNET_PQ_result_spec_auto_from_type (
    264         "access_token",
    265         &td.details.kyc_targets.access_token),
    266       GNUNET_PQ_result_spec_allow_null (
    267         GNUNET_PQ_result_spec_auto_from_type (
    268           "target_pub",
    269           &td.details.kyc_targets.target_pub),
    270         &td.details.kyc_targets.no_account),
    271       GNUNET_PQ_result_spec_bool (
    272         "is_wallet",
    273         &td.details.kyc_targets.is_wallet),
    274       GNUNET_PQ_result_spec_end
    275     };
    276 
    277     if (GNUNET_OK !=
    278         GNUNET_PQ_extract_result (result,
    279                                   rs,
    280                                   i))
    281     {
    282       GNUNET_break (0);
    283       ctx->error = true;
    284       return;
    285     }
    286     ctx->cb (ctx->cb_cls,
    287              &td);
    288     GNUNET_PQ_cleanup_result (rs);
    289   }
    290 }
    291 
    292 
    293 /**
    294  * Function called with reserves table entries.
    295  *
    296  * @param cls closure
    297  * @param result the postgres result
    298  * @param num_results the number of results in @a result
    299  */
    300 static void
    301 lrbt_cb_table_reserves (void *cls,
    302                         PGresult *result,
    303                         unsigned int num_results)
    304 {
    305   struct LookupRecordsByTableContext *ctx = cls;
    306   struct TALER_EXCHANGEDB_TableData td = {
    307     .table = TALER_EXCHANGEDB_RT_RESERVES
    308   };
    309 
    310   for (unsigned int i = 0; i<num_results; i++)
    311   {
    312     struct GNUNET_PQ_ResultSpec rs[] = {
    313       GNUNET_PQ_result_spec_uint64 ("serial",
    314                                     &td.serial),
    315       GNUNET_PQ_result_spec_auto_from_type ("reserve_pub",
    316                                             &td.details.reserves.reserve_pub),
    317       GNUNET_PQ_result_spec_timestamp ("expiration_date",
    318                                        &td.details.reserves.expiration_date),
    319       GNUNET_PQ_result_spec_timestamp ("gc_date",
    320                                        &td.details.reserves.gc_date),
    321       GNUNET_PQ_result_spec_end
    322     };
    323 
    324     if (GNUNET_OK !=
    325         GNUNET_PQ_extract_result (result,
    326                                   rs,
    327                                   i))
    328     {
    329       GNUNET_break (0);
    330       ctx->error = true;
    331       return;
    332     }
    333     ctx->cb (ctx->cb_cls,
    334              &td);
    335     GNUNET_PQ_cleanup_result (rs);
    336   }
    337 }
    338 
    339 
    340 /**
    341  * Function called with reserves_in table entries.
    342  *
    343  * @param cls closure
    344  * @param result the postgres result
    345  * @param num_results the number of results in @a result
    346  */
    347 static void
    348 lrbt_cb_table_reserves_in (void *cls,
    349                            PGresult *result,
    350                            unsigned int num_results)
    351 {
    352   struct LookupRecordsByTableContext *ctx = cls;
    353   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    354   struct TALER_EXCHANGEDB_TableData td = {
    355     .table = TALER_EXCHANGEDB_RT_RESERVES_IN
    356   };
    357 
    358   for (unsigned int i = 0; i<num_results; i++)
    359   {
    360     struct GNUNET_PQ_ResultSpec rs[] = {
    361       GNUNET_PQ_result_spec_uint64 (
    362         "serial",
    363         &td.serial),
    364       GNUNET_PQ_result_spec_auto_from_type (
    365         "reserve_pub",
    366         &td.details.reserves_in.reserve_pub),
    367       GNUNET_PQ_result_spec_uint64 (
    368         "wire_reference",
    369         &td.details.reserves_in.wire_reference),
    370       TALER_PQ_RESULT_SPEC_AMOUNT (
    371         "credit",
    372         &td.details.reserves_in.credit),
    373       GNUNET_PQ_result_spec_auto_from_type (
    374         "wire_source_h_payto",
    375         &td.details.reserves_in.sender_account_h_payto),
    376       GNUNET_PQ_result_spec_string (
    377         "exchange_account_section",
    378         &td.details.reserves_in.exchange_account_section),
    379       GNUNET_PQ_result_spec_timestamp (
    380         "execution_date",
    381         &td.details.reserves_in.execution_date),
    382       GNUNET_PQ_result_spec_end
    383     };
    384 
    385     if (GNUNET_OK !=
    386         GNUNET_PQ_extract_result (result,
    387                                   rs,
    388                                   i))
    389     {
    390       GNUNET_break (0);
    391       ctx->error = true;
    392       return;
    393     }
    394     ctx->cb (ctx->cb_cls,
    395              &td);
    396     GNUNET_PQ_cleanup_result (rs);
    397   }
    398 }
    399 
    400 
    401 /**
    402  * Function called with kycauth_in table entries.
    403  *
    404  * @param cls closure
    405  * @param result the postgres result
    406  * @param num_results the number of results in @a result
    407  */
    408 static void
    409 lrbt_cb_table_kycauth_in (void *cls,
    410                           PGresult *result,
    411                           unsigned int num_results)
    412 {
    413   struct LookupRecordsByTableContext *ctx = cls;
    414   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    415   struct TALER_EXCHANGEDB_TableData td = {
    416     .table = TALER_EXCHANGEDB_RT_KYCAUTHS_IN
    417   };
    418 
    419   for (unsigned int i = 0; i<num_results; i++)
    420   {
    421     struct GNUNET_PQ_ResultSpec rs[] = {
    422       GNUNET_PQ_result_spec_uint64 (
    423         "serial",
    424         &td.serial),
    425       GNUNET_PQ_result_spec_auto_from_type (
    426         "account_pub",
    427         &td.details.kycauth_in.account_pub),
    428       GNUNET_PQ_result_spec_uint64 (
    429         "wire_reference",
    430         &td.details.kycauth_in.wire_reference),
    431       TALER_PQ_RESULT_SPEC_AMOUNT (
    432         "credit",
    433         &td.details.kycauth_in.credit),
    434       GNUNET_PQ_result_spec_auto_from_type (
    435         "wire_source_h_payto",
    436         &td.details.kycauth_in.sender_account_h_payto),
    437       GNUNET_PQ_result_spec_string (
    438         "exchange_account_section",
    439         &td.details.kycauth_in.exchange_account_section),
    440       GNUNET_PQ_result_spec_timestamp (
    441         "execution_date",
    442         &td.details.kycauth_in.execution_date),
    443       GNUNET_PQ_result_spec_end
    444     };
    445 
    446     if (GNUNET_OK !=
    447         GNUNET_PQ_extract_result (result,
    448                                   rs,
    449                                   i))
    450     {
    451       GNUNET_break (0);
    452       ctx->error = true;
    453       return;
    454     }
    455     ctx->cb (ctx->cb_cls,
    456              &td);
    457     GNUNET_PQ_cleanup_result (rs);
    458   }
    459 }
    460 
    461 
    462 /**
    463  * Function called with reserves_close table entries.
    464  *
    465  * @param cls closure
    466  * @param result the postgres result
    467  * @param num_results the number of results in @a result
    468  */
    469 static void
    470 lrbt_cb_table_reserves_close (void *cls,
    471                               PGresult *result,
    472                               unsigned int num_results)
    473 {
    474   struct LookupRecordsByTableContext *ctx = cls;
    475   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    476   struct TALER_EXCHANGEDB_TableData td = {
    477     .table = TALER_EXCHANGEDB_RT_RESERVES_CLOSE
    478   };
    479 
    480   for (unsigned int i = 0; i<num_results; i++)
    481   {
    482     struct GNUNET_PQ_ResultSpec rs[] = {
    483       GNUNET_PQ_result_spec_uint64 (
    484         "serial",
    485         &td.serial),
    486       GNUNET_PQ_result_spec_auto_from_type (
    487         "reserve_pub",
    488         &td.details.reserves_close.reserve_pub),
    489       GNUNET_PQ_result_spec_timestamp (
    490         "execution_date",
    491         &td.details.reserves_close.execution_date),
    492       GNUNET_PQ_result_spec_auto_from_type (
    493         "wtid",
    494         &td.details.reserves_close.wtid),
    495       GNUNET_PQ_result_spec_auto_from_type (
    496         "wire_target_h_payto",
    497         &td.details.reserves_close.sender_account_h_payto),
    498       TALER_PQ_RESULT_SPEC_AMOUNT (
    499         "amount",
    500         &td.details.reserves_close.amount),
    501       TALER_PQ_RESULT_SPEC_AMOUNT (
    502         "closing_fee",
    503         &td.details.reserves_close.closing_fee),
    504       GNUNET_PQ_result_spec_end
    505     };
    506 
    507     if (GNUNET_OK !=
    508         GNUNET_PQ_extract_result (result,
    509                                   rs,
    510                                   i))
    511     {
    512       GNUNET_break (0);
    513       ctx->error = true;
    514       return;
    515     }
    516     ctx->cb (ctx->cb_cls,
    517              &td);
    518     GNUNET_PQ_cleanup_result (rs);
    519   }
    520 }
    521 
    522 
    523 /**
    524  * Function called with reserves_open_requests table entries.
    525  *
    526  * @param cls closure
    527  * @param result the postgres result
    528  * @param num_results the number of results in @a result
    529  */
    530 static void
    531 lrbt_cb_table_reserves_open_requests (void *cls,
    532                                       PGresult *result,
    533                                       unsigned int num_results)
    534 {
    535   struct LookupRecordsByTableContext *ctx = cls;
    536   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    537   struct TALER_EXCHANGEDB_TableData td = {
    538     .table = TALER_EXCHANGEDB_RT_RESERVES_OPEN_REQUESTS
    539   };
    540 
    541   for (unsigned int i = 0; i<num_results; i++)
    542   {
    543     struct GNUNET_PQ_ResultSpec rs[] = {
    544       GNUNET_PQ_result_spec_uint64 ("serial",
    545                                     &td.serial),
    546       GNUNET_PQ_result_spec_auto_from_type (
    547         "reserve_pub",
    548         &td.details.reserves_open_requests.reserve_pub),
    549       GNUNET_PQ_result_spec_timestamp (
    550         "request_timestamp",
    551         &td.details.reserves_open_requests.request_timestamp),
    552       GNUNET_PQ_result_spec_timestamp (
    553         "expiration_date",
    554         &td.details.reserves_open_requests.expiration_date),
    555       GNUNET_PQ_result_spec_auto_from_type (
    556         "reserve_sig",
    557         &td.details.reserves_open_requests.reserve_sig),
    558       TALER_PQ_RESULT_SPEC_AMOUNT (
    559         "reserve_payment",
    560         &td.details.reserves_open_requests.reserve_payment),
    561       GNUNET_PQ_result_spec_uint32 (
    562         "requested_purse_limit",
    563         &td.details.reserves_open_requests.requested_purse_limit),
    564       GNUNET_PQ_result_spec_end
    565     };
    566 
    567     if (GNUNET_OK !=
    568         GNUNET_PQ_extract_result (result,
    569                                   rs,
    570                                   i))
    571     {
    572       GNUNET_break (0);
    573       ctx->error = true;
    574       return;
    575     }
    576     ctx->cb (ctx->cb_cls,
    577              &td);
    578     GNUNET_PQ_cleanup_result (rs);
    579   }
    580 }
    581 
    582 
    583 /**
    584  * Function called with reserves_open_deposits table entries.
    585  *
    586  * @param cls closure
    587  * @param result the postgres result
    588  * @param num_results the number of results in @a result
    589  */
    590 static void
    591 lrbt_cb_table_reserves_open_deposits (void *cls,
    592                                       PGresult *result,
    593                                       unsigned int num_results)
    594 {
    595   struct LookupRecordsByTableContext *ctx = cls;
    596   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    597   struct TALER_EXCHANGEDB_TableData td = {
    598     .table = TALER_EXCHANGEDB_RT_RESERVES_OPEN_DEPOSITS
    599   };
    600 
    601   for (unsigned int i = 0; i<num_results; i++)
    602   {
    603     struct GNUNET_PQ_ResultSpec rs[] = {
    604       GNUNET_PQ_result_spec_uint64 ("serial",
    605                                     &td.serial),
    606       GNUNET_PQ_result_spec_auto_from_type (
    607         "reserve_sig",
    608         &td.details.reserves_open_deposits.reserve_sig),
    609       GNUNET_PQ_result_spec_auto_from_type (
    610         "reserve_pub",
    611         &td.details.reserves_open_deposits.reserve_pub),
    612       GNUNET_PQ_result_spec_auto_from_type (
    613         "coin_pub",
    614         &td.details.reserves_open_deposits.coin_pub),
    615       GNUNET_PQ_result_spec_auto_from_type (
    616         "coin_sig",
    617         &td.details.reserves_open_deposits.coin_sig),
    618       TALER_PQ_RESULT_SPEC_AMOUNT (
    619         "contribution",
    620         &td.details.reserves_open_deposits.contribution),
    621       GNUNET_PQ_result_spec_end
    622     };
    623 
    624     if (GNUNET_OK !=
    625         GNUNET_PQ_extract_result (result,
    626                                   rs,
    627                                   i))
    628     {
    629       GNUNET_break (0);
    630       ctx->error = true;
    631       return;
    632     }
    633     ctx->cb (ctx->cb_cls,
    634              &td);
    635     GNUNET_PQ_cleanup_result (rs);
    636   }
    637 }
    638 
    639 
    640 /**
    641  * Function called with auditors table entries.
    642  *
    643  * @param cls closure
    644  * @param result the postgres result
    645  * @param num_results the number of results in @a result
    646  */
    647 static void
    648 lrbt_cb_table_auditors (void *cls,
    649                         PGresult *result,
    650                         unsigned int num_results)
    651 {
    652   struct LookupRecordsByTableContext *ctx = cls;
    653   struct TALER_EXCHANGEDB_TableData td = {
    654     .table = TALER_EXCHANGEDB_RT_AUDITORS
    655   };
    656 
    657   for (unsigned int i = 0; i<num_results; i++)
    658   {
    659     struct GNUNET_PQ_ResultSpec rs[] = {
    660       GNUNET_PQ_result_spec_uint64 ("serial",
    661                                     &td.serial),
    662       GNUNET_PQ_result_spec_auto_from_type ("auditor_pub",
    663                                             &td.details.auditors.auditor_pub),
    664       GNUNET_PQ_result_spec_string ("auditor_url",
    665                                     &td.details.auditors.auditor_url),
    666       GNUNET_PQ_result_spec_string ("auditor_name",
    667                                     &td.details.auditors.auditor_name),
    668       GNUNET_PQ_result_spec_bool ("is_active",
    669                                   &td.details.auditors.is_active),
    670       GNUNET_PQ_result_spec_timestamp ("last_change",
    671                                        &td.details.auditors.last_change),
    672       GNUNET_PQ_result_spec_end
    673     };
    674 
    675     if (GNUNET_OK !=
    676         GNUNET_PQ_extract_result (result,
    677                                   rs,
    678                                   i))
    679     {
    680       GNUNET_break (0);
    681       ctx->error = true;
    682       return;
    683     }
    684     ctx->cb (ctx->cb_cls,
    685              &td);
    686     GNUNET_PQ_cleanup_result (rs);
    687   }
    688 }
    689 
    690 
    691 /**
    692  * Function called with auditor_denom_sigs table entries.
    693  *
    694  * @param cls closure
    695  * @param result the postgres result
    696  * @param num_results the number of results in @a result
    697  */
    698 static void
    699 lrbt_cb_table_auditor_denom_sigs (void *cls,
    700                                   PGresult *result,
    701                                   unsigned int num_results)
    702 {
    703   struct LookupRecordsByTableContext *ctx = cls;
    704   struct TALER_EXCHANGEDB_TableData td = {
    705     .table = TALER_EXCHANGEDB_RT_AUDITOR_DENOM_SIGS
    706   };
    707 
    708   for (unsigned int i = 0; i<num_results; i++)
    709   {
    710     struct GNUNET_PQ_ResultSpec rs[] = {
    711       GNUNET_PQ_result_spec_uint64 (
    712         "serial",
    713         &td.serial),
    714       GNUNET_PQ_result_spec_uint64 (
    715         "auditor_uuid",
    716         &td.details.auditor_denom_sigs.auditor_uuid),
    717       GNUNET_PQ_result_spec_uint64 (
    718         "denominations_serial",
    719         &td.details.auditor_denom_sigs.denominations_serial),
    720       GNUNET_PQ_result_spec_auto_from_type (
    721         "auditor_sig",
    722         &td.details.auditor_denom_sigs.auditor_sig),
    723       GNUNET_PQ_result_spec_end
    724     };
    725 
    726     if (GNUNET_OK !=
    727         GNUNET_PQ_extract_result (result,
    728                                   rs,
    729                                   i))
    730     {
    731       GNUNET_break (0);
    732       ctx->error = true;
    733       return;
    734     }
    735     ctx->cb (ctx->cb_cls,
    736              &td);
    737     GNUNET_PQ_cleanup_result (rs);
    738   }
    739 }
    740 
    741 
    742 /**
    743  * Function called with exchange_sign_keys table entries.
    744  *
    745  * @param cls closure
    746  * @param result the postgres result
    747  * @param num_results the number of results in @a result
    748  */
    749 static void
    750 lrbt_cb_table_exchange_sign_keys (void *cls,
    751                                   PGresult *result,
    752                                   unsigned int num_results)
    753 {
    754   struct LookupRecordsByTableContext *ctx = cls;
    755   struct TALER_EXCHANGEDB_TableData td = {
    756     .table = TALER_EXCHANGEDB_RT_EXCHANGE_SIGN_KEYS
    757   };
    758 
    759   for (unsigned int i = 0; i<num_results; i++)
    760   {
    761     struct GNUNET_PQ_ResultSpec rs[] = {
    762       GNUNET_PQ_result_spec_uint64 ("serial",
    763                                     &td.serial),
    764       GNUNET_PQ_result_spec_auto_from_type ("exchange_pub",
    765                                             &td.details.exchange_sign_keys.
    766                                             exchange_pub),
    767       GNUNET_PQ_result_spec_auto_from_type ("master_sig",
    768                                             &td.details.exchange_sign_keys.
    769                                             master_sig),
    770       GNUNET_PQ_result_spec_timestamp ("valid_from",
    771                                        &td.details.exchange_sign_keys.meta.
    772                                        start),
    773       GNUNET_PQ_result_spec_timestamp ("expire_sign",
    774                                        &td.details.exchange_sign_keys.meta.
    775                                        expire_sign),
    776       GNUNET_PQ_result_spec_timestamp ("expire_legal",
    777                                        &td.details.exchange_sign_keys.meta.
    778                                        expire_legal),
    779       GNUNET_PQ_result_spec_end
    780     };
    781 
    782     if (GNUNET_OK !=
    783         GNUNET_PQ_extract_result (result,
    784                                   rs,
    785                                   i))
    786     {
    787       GNUNET_break (0);
    788       ctx->error = true;
    789       return;
    790     }
    791     ctx->cb (ctx->cb_cls,
    792              &td);
    793     GNUNET_PQ_cleanup_result (rs);
    794   }
    795 }
    796 
    797 
    798 /**
    799  * Function called with signkey_revocations table entries.
    800  *
    801  * @param cls closure
    802  * @param result the postgres result
    803  * @param num_results the number of results in @a result
    804  */
    805 static void
    806 lrbt_cb_table_signkey_revocations (void *cls,
    807                                    PGresult *result,
    808                                    unsigned int num_results)
    809 {
    810   struct LookupRecordsByTableContext *ctx = cls;
    811   struct TALER_EXCHANGEDB_TableData td = {
    812     .table = TALER_EXCHANGEDB_RT_SIGNKEY_REVOCATIONS
    813   };
    814 
    815   for (unsigned int i = 0; i<num_results; i++)
    816   {
    817     struct GNUNET_PQ_ResultSpec rs[] = {
    818       GNUNET_PQ_result_spec_uint64 ("serial",
    819                                     &td.serial),
    820       GNUNET_PQ_result_spec_uint64 ("esk_serial",
    821                                     &td.details.signkey_revocations.esk_serial),
    822       GNUNET_PQ_result_spec_auto_from_type ("master_sig",
    823                                             &td.details.signkey_revocations.
    824                                             master_sig),
    825       GNUNET_PQ_result_spec_end
    826     };
    827 
    828     if (GNUNET_OK !=
    829         GNUNET_PQ_extract_result (result,
    830                                   rs,
    831                                   i))
    832     {
    833       GNUNET_break (0);
    834       ctx->error = true;
    835       return;
    836     }
    837     ctx->cb (ctx->cb_cls,
    838              &td);
    839     GNUNET_PQ_cleanup_result (rs);
    840   }
    841 }
    842 
    843 
    844 /**
    845  * Function called with known_coins table entries.
    846  *
    847  * @param cls closure
    848  * @param result the postgres result
    849  * @param num_results the number of results in @a result
    850  */
    851 static void
    852 lrbt_cb_table_known_coins (void *cls,
    853                            PGresult *result,
    854                            unsigned int num_results)
    855 {
    856   struct LookupRecordsByTableContext *ctx = cls;
    857   struct TALER_EXCHANGEDB_TableData td = {
    858     .table = TALER_EXCHANGEDB_RT_KNOWN_COINS
    859   };
    860 
    861   for (unsigned int i = 0; i<num_results; i++)
    862   {
    863     struct GNUNET_PQ_ResultSpec rs[] = {
    864       GNUNET_PQ_result_spec_uint64 (
    865         "serial",
    866         &td.serial),
    867       GNUNET_PQ_result_spec_auto_from_type (
    868         "coin_pub",
    869         &td.details.known_coins.coin_pub),
    870       TALER_PQ_result_spec_denom_sig (
    871         "denom_sig",
    872         &td.details.known_coins.denom_sig),
    873       GNUNET_PQ_result_spec_uint64 (
    874         "denominations_serial",
    875         &td.details.known_coins.denominations_serial),
    876       GNUNET_PQ_result_spec_end
    877     };
    878 
    879     if (GNUNET_OK !=
    880         GNUNET_PQ_extract_result (result,
    881                                   rs,
    882                                   i))
    883     {
    884       GNUNET_break (0);
    885       ctx->error = true;
    886       return;
    887     }
    888     ctx->cb (ctx->cb_cls,
    889              &td);
    890     GNUNET_PQ_cleanup_result (rs);
    891   }
    892 }
    893 
    894 
    895 /**
    896  * Function called with refresh table entries.
    897  *
    898  * @param cls closure
    899  * @param result the postgres result
    900  * @param num_results the number of results in @a result
    901  */
    902 static void
    903 lrbt_cb_table_refresh (void *cls,
    904                        PGresult *result,
    905                        unsigned int num_results)
    906 {
    907   struct LookupRecordsByTableContext *ctx = cls;
    908   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
    909   struct TALER_EXCHANGEDB_TableData td = {
    910     .table = TALER_EXCHANGEDB_RT_REFRESH
    911   };
    912 
    913   for (unsigned int i = 0; i<num_results; i++)
    914   {
    915     bool no_cs_r_values;
    916     bool no_cs_r_choices;
    917     bool no_transfer_pubs;
    918     size_t num_denom_sigs;
    919     size_t num_transfer_pubs;
    920     struct GNUNET_PQ_ResultSpec rs[] = {
    921       GNUNET_PQ_result_spec_uint64 (
    922         "serial",
    923         &td.serial),
    924       GNUNET_PQ_result_spec_auto_from_type (
    925         "rc",
    926         &td.details.refresh.rc),
    927       GNUNET_PQ_result_spec_auto_from_type (
    928         "execution_date",
    929         &td.details.refresh.execution_date),
    930       TALER_PQ_RESULT_SPEC_AMOUNT (
    931         "amount_with_fee",
    932         &td.details.refresh.amount_with_fee),
    933       GNUNET_PQ_result_spec_auto_from_type (
    934         "old_coin_pub",
    935         &td.details.refresh.old_coin_pub),
    936       GNUNET_PQ_result_spec_auto_from_type (
    937         "old_coin_sig",
    938         &td.details.refresh.old_coin_sig),
    939       GNUNET_PQ_result_spec_auto_from_type (
    940         "refresh_seed",
    941         &td.details.refresh.refresh_seed),
    942       GNUNET_PQ_result_spec_uint32 (
    943         "noreveal_index",
    944         &td.details.refresh.noreveal_index),
    945       GNUNET_PQ_result_spec_auto_from_type (
    946         "planchets_h",
    947         &td.details.refresh.planchets_h),
    948       GNUNET_PQ_result_spec_auto_from_type (
    949         "selected_h",
    950         &td.details.refresh.selected_h),
    951       GNUNET_PQ_result_spec_allow_null (
    952         GNUNET_PQ_result_spec_auto_from_type (
    953           "blinding_seed",
    954           &td.details.refresh.blinding_seed),
    955         &td.details.refresh.no_blinding_seed),
    956       GNUNET_PQ_result_spec_allow_null (
    957         TALER_PQ_result_spec_array_cs_r_pub (
    958           pg->conn,
    959           "cs_r_values",
    960           &td.details.refresh.num_cs_r_values,
    961           &td.details.refresh.cs_r_values),
    962         &no_cs_r_values),
    963       GNUNET_PQ_result_spec_allow_null (
    964         GNUNET_PQ_result_spec_uint64 (
    965           "cs_r_choices",
    966           &td.details.refresh.cs_r_choices),
    967         &no_cs_r_choices),
    968       GNUNET_PQ_result_spec_array_uint64 (
    969         pg->conn,
    970         "denom_serials",
    971         &td.details.refresh.num_coins,
    972         &td.details.refresh.denom_serials),
    973       TALER_PQ_result_spec_array_blinded_denom_sig (
    974         pg->conn,
    975         "denom_sigs",
    976         &num_denom_sigs,
    977         &td.details.refresh.denom_sigs),
    978       GNUNET_PQ_result_spec_allow_null (
    979         GNUNET_PQ_result_spec_array_fixed_size (
    980           pg->conn,
    981           "transfer_pubs",
    982           sizeof (*td.details.refresh.transfer_pubs),
    983           &num_transfer_pubs,
    984           (void **) &td.details.refresh.transfer_pubs),
    985         &no_transfer_pubs),
    986       GNUNET_PQ_result_spec_bool (
    987         "revealed",
    988         &td.details.refresh.revealed),
    989       GNUNET_PQ_result_spec_uint32 (
    990         "rc_version",
    991         &td.details.refresh.rc_version),
    992       GNUNET_PQ_result_spec_end
    993     };
    994 
    995     td.details.refresh.transfer_pubs = NULL;
    996     if (GNUNET_OK !=
    997         GNUNET_PQ_extract_result (result,
    998                                   rs,
    999                                   i))
   1000     {
   1001       GNUNET_break (0);
   1002       ctx->error = true;
   1003       GNUNET_PQ_cleanup_result (rs);
   1004       return;
   1005     }
   1006     if ( (num_denom_sigs != td.details.refresh.num_coins) ||
   1007          ( (! no_transfer_pubs) &&
   1008            (num_transfer_pubs != td.details.refresh.num_coins) ) )
   1009     {
   1010       GNUNET_break (0);
   1011       ctx->error = true;
   1012       GNUNET_PQ_cleanup_result (rs);
   1013       return;
   1014     }
   1015     ctx->cb (ctx->cb_cls,
   1016              &td);
   1017     GNUNET_PQ_cleanup_result (rs);
   1018   }
   1019 }
   1020 
   1021 
   1022 /**
   1023  * Function called with batch deposits table entries.
   1024  *
   1025  * @param cls closure
   1026  * @param result the postgres result
   1027  * @param num_results the number of results in @a result
   1028  */
   1029 static void
   1030 lrbt_cb_table_batch_deposits (void *cls,
   1031                               PGresult *result,
   1032                               unsigned int num_results)
   1033 {
   1034   struct LookupRecordsByTableContext *ctx = cls;
   1035   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1036   struct TALER_EXCHANGEDB_TableData td = {
   1037     .table = TALER_EXCHANGEDB_RT_BATCH_DEPOSITS
   1038   };
   1039 
   1040   for (unsigned int i = 0; i<num_results; i++)
   1041   {
   1042     struct GNUNET_PQ_ResultSpec rs[] = {
   1043       GNUNET_PQ_result_spec_uint64 (
   1044         "serial",
   1045         &td.serial),
   1046       GNUNET_PQ_result_spec_uint64 (
   1047         "shard",
   1048         &td.details.batch_deposits.shard),
   1049       GNUNET_PQ_result_spec_auto_from_type (
   1050         "merchant_pub",
   1051         &td.details.batch_deposits.merchant_pub),
   1052       GNUNET_PQ_result_spec_timestamp (
   1053         "wallet_timestamp",
   1054         &td.details.batch_deposits.wallet_timestamp),
   1055       GNUNET_PQ_result_spec_timestamp (
   1056         "exchange_timestamp",
   1057         &td.details.batch_deposits.exchange_timestamp),
   1058       GNUNET_PQ_result_spec_timestamp (
   1059         "refund_deadline",
   1060         &td.details.batch_deposits.refund_deadline),
   1061       GNUNET_PQ_result_spec_timestamp (
   1062         "wire_deadline",
   1063         &td.details.batch_deposits.wire_deadline),
   1064       GNUNET_PQ_result_spec_auto_from_type (
   1065         "h_contract_terms",
   1066         &td.details.batch_deposits.h_contract_terms),
   1067       GNUNET_PQ_result_spec_allow_null (
   1068         GNUNET_PQ_result_spec_auto_from_type (
   1069           "wallet_data_hash",
   1070           &td.details.batch_deposits.wallet_data_hash),
   1071         &td.details.batch_deposits.no_wallet_data_hash),
   1072       GNUNET_PQ_result_spec_auto_from_type (
   1073         "wire_salt",
   1074         &td.details.batch_deposits.wire_salt),
   1075       GNUNET_PQ_result_spec_auto_from_type (
   1076         "wire_target_h_payto",
   1077         &td.details.batch_deposits.wire_target_h_payto),
   1078       TALER_PQ_RESULT_SPEC_AMOUNT (
   1079         "total_amount",
   1080         &td.details.batch_deposits.total_amount),
   1081       TALER_PQ_RESULT_SPEC_AMOUNT (
   1082         "total_without_fee",
   1083         &td.details.batch_deposits.total_without_fee),
   1084       GNUNET_PQ_result_spec_auto_from_type (
   1085         "merchant_sig",
   1086         &td.details.batch_deposits.merchant_sig),
   1087       GNUNET_PQ_result_spec_bool (
   1088         "done",
   1089         &td.details.batch_deposits.done),
   1090       GNUNET_PQ_result_spec_end
   1091     };
   1092 
   1093     if (GNUNET_OK !=
   1094         GNUNET_PQ_extract_result (result,
   1095                                   rs,
   1096                                   i))
   1097     {
   1098       GNUNET_break (0);
   1099       ctx->error = true;
   1100       return;
   1101     }
   1102     ctx->cb (ctx->cb_cls,
   1103              &td);
   1104     GNUNET_PQ_cleanup_result (rs);
   1105   }
   1106 }
   1107 
   1108 
   1109 /**
   1110  * Function called with coin deposits table entries.
   1111  *
   1112  * @param cls closure
   1113  * @param result the postgres result
   1114  * @param num_results the number of results in @a result
   1115  */
   1116 static void
   1117 lrbt_cb_table_coin_deposits (void *cls,
   1118                              PGresult *result,
   1119                              unsigned int num_results)
   1120 {
   1121   struct LookupRecordsByTableContext *ctx = cls;
   1122   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1123   struct TALER_EXCHANGEDB_TableData td = {
   1124     .table = TALER_EXCHANGEDB_RT_COIN_DEPOSITS
   1125   };
   1126 
   1127   for (unsigned int i = 0; i<num_results; i++)
   1128   {
   1129     struct GNUNET_PQ_ResultSpec rs[] = {
   1130       GNUNET_PQ_result_spec_uint64 (
   1131         "serial",
   1132         &td.serial),
   1133       GNUNET_PQ_result_spec_uint64 (
   1134         "batch_deposit_serial_id",
   1135         &td.details.coin_deposits.batch_deposit_serial_id),
   1136       GNUNET_PQ_result_spec_auto_from_type (
   1137         "coin_pub",
   1138         &td.details.coin_deposits.coin_pub),
   1139       GNUNET_PQ_result_spec_auto_from_type (
   1140         "coin_sig",
   1141         &td.details.coin_deposits.coin_sig),
   1142       TALER_PQ_RESULT_SPEC_AMOUNT (
   1143         "amount_with_fee",
   1144         &td.details.coin_deposits.amount_with_fee),
   1145       GNUNET_PQ_result_spec_end
   1146     };
   1147 
   1148     if (GNUNET_OK !=
   1149         GNUNET_PQ_extract_result (result,
   1150                                   rs,
   1151                                   i))
   1152     {
   1153       GNUNET_break (0);
   1154       ctx->error = true;
   1155       return;
   1156     }
   1157     ctx->cb (ctx->cb_cls,
   1158              &td);
   1159     GNUNET_PQ_cleanup_result (rs);
   1160   }
   1161 }
   1162 
   1163 
   1164 /**
   1165  * Function called with refunds table entries.
   1166  *
   1167  * @param cls closure
   1168  * @param result the postgres result
   1169  * @param num_results the number of results in @a result
   1170  */
   1171 static void
   1172 lrbt_cb_table_refunds (void *cls,
   1173                        PGresult *result,
   1174                        unsigned int num_results)
   1175 {
   1176   struct LookupRecordsByTableContext *ctx = cls;
   1177   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1178   struct TALER_EXCHANGEDB_TableData td = {
   1179     .table = TALER_EXCHANGEDB_RT_REFUNDS
   1180   };
   1181 
   1182   for (unsigned int i = 0; i<num_results; i++)
   1183   {
   1184     struct GNUNET_PQ_ResultSpec rs[] = {
   1185       GNUNET_PQ_result_spec_uint64 (
   1186         "serial",
   1187         &td.serial),
   1188       GNUNET_PQ_result_spec_auto_from_type (
   1189         "coin_pub",
   1190         &td.details.refunds.coin_pub),
   1191       GNUNET_PQ_result_spec_auto_from_type (
   1192         "merchant_sig",
   1193         &td.details.refunds.merchant_sig),
   1194       GNUNET_PQ_result_spec_uint64 (
   1195         "rtransaction_id",
   1196         &td.details.refunds.rtransaction_id),
   1197       TALER_PQ_RESULT_SPEC_AMOUNT (
   1198         "amount_with_fee",
   1199         &td.details.refunds.amount_with_fee),
   1200       GNUNET_PQ_result_spec_uint64 (
   1201         "batch_deposit_serial_id",
   1202         &td.details.refunds.batch_deposit_serial_id),
   1203       GNUNET_PQ_result_spec_end
   1204     };
   1205 
   1206     if (GNUNET_OK !=
   1207         GNUNET_PQ_extract_result (result,
   1208                                   rs,
   1209                                   i))
   1210     {
   1211       GNUNET_break (0);
   1212       ctx->error = true;
   1213       return;
   1214     }
   1215     ctx->cb (ctx->cb_cls,
   1216              &td);
   1217     GNUNET_PQ_cleanup_result (rs);
   1218   }
   1219 }
   1220 
   1221 
   1222 /**
   1223  * Function called with wire_out table entries.
   1224  *
   1225  * @param cls closure
   1226  * @param result the postgres result
   1227  * @param num_results the number of results in @a result
   1228  */
   1229 static void
   1230 lrbt_cb_table_wire_out (void *cls,
   1231                         PGresult *result,
   1232                         unsigned int num_results)
   1233 {
   1234   struct LookupRecordsByTableContext *ctx = cls;
   1235   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1236   struct TALER_EXCHANGEDB_TableData td = {
   1237     .table = TALER_EXCHANGEDB_RT_WIRE_OUT
   1238   };
   1239 
   1240   for (unsigned int i = 0; i<num_results; i++)
   1241   {
   1242     struct GNUNET_PQ_ResultSpec rs[] = {
   1243       GNUNET_PQ_result_spec_uint64 ("serial",
   1244                                     &td.serial),
   1245       GNUNET_PQ_result_spec_timestamp (
   1246         "execution_date",
   1247         &td.details.wire_out.execution_date),
   1248       GNUNET_PQ_result_spec_auto_from_type (
   1249         "wtid_raw",
   1250         &td.details.wire_out.wtid_raw),
   1251       GNUNET_PQ_result_spec_auto_from_type (
   1252         "wire_target_h_payto",
   1253         &td.details.wire_out.wire_target_h_payto),
   1254       GNUNET_PQ_result_spec_string (
   1255         "exchange_account_section",
   1256         &td.details.wire_out.exchange_account_section),
   1257       TALER_PQ_RESULT_SPEC_AMOUNT (
   1258         "amount",
   1259         &td.details.wire_out.amount),
   1260       GNUNET_PQ_result_spec_end
   1261     };
   1262 
   1263     if (GNUNET_OK !=
   1264         GNUNET_PQ_extract_result (result,
   1265                                   rs,
   1266                                   i))
   1267     {
   1268       GNUNET_break (0);
   1269       ctx->error = true;
   1270       return;
   1271     }
   1272     ctx->cb (ctx->cb_cls,
   1273              &td);
   1274     GNUNET_PQ_cleanup_result (rs);
   1275   }
   1276 }
   1277 
   1278 
   1279 /**
   1280  * Function called with aggregation_deferrals table entries.
   1281  *
   1282  * @param cls closure
   1283  * @param result the postgres result
   1284  * @param num_results the number of results in @a result
   1285  */
   1286 static void
   1287 lrbt_cb_table_aggregation_deferrals (void *cls,
   1288                                      PGresult *result,
   1289                                      unsigned int num_results)
   1290 {
   1291   struct LookupRecordsByTableContext *ctx = cls;
   1292   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1293   struct TALER_EXCHANGEDB_TableData td = {
   1294     .table = TALER_EXCHANGEDB_RT_AGGREGATION_DEFERRALS
   1295   };
   1296 
   1297   for (unsigned int i = 0; i<num_results; i++)
   1298   {
   1299     struct GNUNET_PQ_ResultSpec rs[] = {
   1300       GNUNET_PQ_result_spec_uint64 (
   1301         "serial",
   1302         &td.serial),
   1303       GNUNET_PQ_result_spec_uint64 (
   1304         "batch_deposit_serial_id",
   1305         &td.details.aggregation_deferrals.batch_deposit_serial_id),
   1306       GNUNET_PQ_result_spec_auto_from_type (
   1307         "wtid_raw",
   1308         &td.details.aggregation_deferrals.wtid_raw),
   1309       GNUNET_PQ_result_spec_auto_from_type (
   1310         "wire_target_h_payto",
   1311         &td.details.aggregation_deferrals.wire_target_h_payto),
   1312       TALER_PQ_RESULT_SPEC_AMOUNT (
   1313         "amount",
   1314         &td.details.aggregation_deferrals.amount),
   1315       GNUNET_PQ_result_spec_uint32 (
   1316         "deferral_reason",
   1317         &td.details.aggregation_deferrals.deferral_reason),
   1318       GNUNET_PQ_result_spec_uint64 (
   1319         "legitimization_requirement_serial_id",
   1320         &td.details.aggregation_deferrals.legitimization_requirement_serial_id),
   1321       GNUNET_PQ_result_spec_timestamp (
   1322         "deferral_time",
   1323         &td.details.aggregation_deferrals.deferral_time),
   1324       GNUNET_PQ_result_spec_end
   1325     };
   1326 
   1327     if (GNUNET_OK !=
   1328         GNUNET_PQ_extract_result (result,
   1329                                   rs,
   1330                                   i))
   1331     {
   1332       GNUNET_break (0);
   1333       ctx->error = true;
   1334       return;
   1335     }
   1336     ctx->cb (ctx->cb_cls,
   1337              &td);
   1338     GNUNET_PQ_cleanup_result (rs);
   1339   }
   1340 }
   1341 
   1342 
   1343 /**
   1344  * Function called with aggregation_tracking table entries.
   1345  *
   1346  * @param cls closure
   1347  * @param result the postgres result
   1348  * @param num_results the number of results in @a result
   1349  */
   1350 static void
   1351 lrbt_cb_table_aggregation_tracking (void *cls,
   1352                                     PGresult *result,
   1353                                     unsigned int num_results)
   1354 {
   1355   struct LookupRecordsByTableContext *ctx = cls;
   1356   struct TALER_EXCHANGEDB_TableData td = {
   1357     .table = TALER_EXCHANGEDB_RT_AGGREGATION_TRACKING
   1358   };
   1359 
   1360   for (unsigned int i = 0; i<num_results; i++)
   1361   {
   1362     struct GNUNET_PQ_ResultSpec rs[] = {
   1363       GNUNET_PQ_result_spec_uint64 (
   1364         "serial",
   1365         &td.serial),
   1366       GNUNET_PQ_result_spec_uint64 (
   1367         "batch_deposit_serial_id",
   1368         &td.details.aggregation_tracking.batch_deposit_serial_id),
   1369       GNUNET_PQ_result_spec_auto_from_type (
   1370         "wtid_raw",
   1371         &td.details.aggregation_tracking.wtid_raw),
   1372       GNUNET_PQ_result_spec_end
   1373     };
   1374 
   1375     if (GNUNET_OK !=
   1376         GNUNET_PQ_extract_result (result,
   1377                                   rs,
   1378                                   i))
   1379     {
   1380       GNUNET_break (0);
   1381       ctx->error = true;
   1382       return;
   1383     }
   1384     ctx->cb (ctx->cb_cls,
   1385              &td);
   1386     GNUNET_PQ_cleanup_result (rs);
   1387   }
   1388 }
   1389 
   1390 
   1391 /**
   1392  * Function called with wire_fee table entries.
   1393  *
   1394  * @param cls closure
   1395  * @param result the postgres result
   1396  * @param num_results the number of results in @a result
   1397  */
   1398 static void
   1399 lrbt_cb_table_wire_fee (void *cls,
   1400                         PGresult *result,
   1401                         unsigned int num_results)
   1402 {
   1403   struct LookupRecordsByTableContext *ctx = cls;
   1404   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1405   struct TALER_EXCHANGEDB_TableData td = {
   1406     .table = TALER_EXCHANGEDB_RT_WIRE_FEE
   1407   };
   1408 
   1409   for (unsigned int i = 0; i<num_results; i++)
   1410   {
   1411     struct GNUNET_PQ_ResultSpec rs[] = {
   1412       GNUNET_PQ_result_spec_uint64 ("serial",
   1413                                     &td.serial),
   1414       GNUNET_PQ_result_spec_string ("wire_method",
   1415                                     &td.details.wire_fee.wire_method),
   1416       GNUNET_PQ_result_spec_timestamp ("start_date",
   1417                                        &td.details.wire_fee.start_date),
   1418       GNUNET_PQ_result_spec_timestamp ("end_date",
   1419                                        &td.details.wire_fee.end_date),
   1420       TALER_PQ_RESULT_SPEC_AMOUNT ("wire_fee",
   1421                                    &td.details.wire_fee.fees.wire),
   1422       TALER_PQ_RESULT_SPEC_AMOUNT ("closing_fee",
   1423                                    &td.details.wire_fee.fees.closing),
   1424       GNUNET_PQ_result_spec_auto_from_type ("master_sig",
   1425                                             &td.details.wire_fee.master_sig),
   1426       GNUNET_PQ_result_spec_end
   1427     };
   1428 
   1429     if (GNUNET_OK !=
   1430         GNUNET_PQ_extract_result (result,
   1431                                   rs,
   1432                                   i))
   1433     {
   1434       GNUNET_break (0);
   1435       ctx->error = true;
   1436       return;
   1437     }
   1438     ctx->cb (ctx->cb_cls,
   1439              &td);
   1440     GNUNET_PQ_cleanup_result (rs);
   1441   }
   1442 }
   1443 
   1444 
   1445 /**
   1446  * Function called with wire_fee table entries.
   1447  *
   1448  * @param cls closure
   1449  * @param result the postgres result
   1450  * @param num_results the number of results in @a result
   1451  */
   1452 static void
   1453 lrbt_cb_table_global_fee (void *cls,
   1454                           PGresult *result,
   1455                           unsigned int num_results)
   1456 {
   1457   struct LookupRecordsByTableContext *ctx = cls;
   1458   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1459   struct TALER_EXCHANGEDB_TableData td = {
   1460     .table = TALER_EXCHANGEDB_RT_GLOBAL_FEE
   1461   };
   1462 
   1463   for (unsigned int i = 0; i<num_results; i++)
   1464   {
   1465     struct GNUNET_PQ_ResultSpec rs[] = {
   1466       GNUNET_PQ_result_spec_uint64 (
   1467         "serial",
   1468         &td.serial),
   1469       GNUNET_PQ_result_spec_timestamp (
   1470         "start_date",
   1471         &td.details.global_fee.start_date),
   1472       GNUNET_PQ_result_spec_timestamp (
   1473         "end_date",
   1474         &td.details.global_fee.end_date),
   1475       TALER_PQ_RESULT_SPEC_AMOUNT (
   1476         "history_fee",
   1477         &td.details.global_fee.fees.history),
   1478       TALER_PQ_RESULT_SPEC_AMOUNT (
   1479         "account_fee",
   1480         &td.details.global_fee.fees.account),
   1481       TALER_PQ_RESULT_SPEC_AMOUNT (
   1482         "purse_fee",
   1483         &td.details.global_fee.fees.purse),
   1484       GNUNET_PQ_result_spec_relative_time (
   1485         "purse_timeout",
   1486         &td.details.global_fee.purse_timeout),
   1487       GNUNET_PQ_result_spec_relative_time (
   1488         "history_expiration",
   1489         &td.details.global_fee.history_expiration),
   1490       GNUNET_PQ_result_spec_uint32 (
   1491         "purse_account_limit",
   1492         &td.details.global_fee.purse_account_limit),
   1493       GNUNET_PQ_result_spec_auto_from_type (
   1494         "master_sig",
   1495         &td.details.global_fee.master_sig),
   1496       GNUNET_PQ_result_spec_end
   1497     };
   1498 
   1499     if (GNUNET_OK !=
   1500         GNUNET_PQ_extract_result (result,
   1501                                   rs,
   1502                                   i))
   1503     {
   1504       GNUNET_break (0);
   1505       ctx->error = true;
   1506       return;
   1507     }
   1508     ctx->cb (ctx->cb_cls,
   1509              &td);
   1510     GNUNET_PQ_cleanup_result (rs);
   1511   }
   1512 }
   1513 
   1514 
   1515 /**
   1516  * Function called with recoup table entries.
   1517  *
   1518  * @param cls closure
   1519  * @param result the postgres result
   1520  * @param num_results the number of results in @a result
   1521  */
   1522 static void
   1523 lrbt_cb_table_recoup (void *cls,
   1524                       PGresult *result,
   1525                       unsigned int num_results)
   1526 {
   1527   struct LookupRecordsByTableContext *ctx = cls;
   1528   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1529   struct TALER_EXCHANGEDB_TableData td = {
   1530     .table = TALER_EXCHANGEDB_RT_RECOUP
   1531   };
   1532 
   1533   for (unsigned int i = 0; i<num_results; i++)
   1534   {
   1535     struct GNUNET_PQ_ResultSpec rs[] = {
   1536       GNUNET_PQ_result_spec_uint64 ("serial",
   1537                                     &td.serial),
   1538       GNUNET_PQ_result_spec_auto_from_type ("coin_sig",
   1539                                             &td.details.recoup.coin_sig),
   1540       GNUNET_PQ_result_spec_auto_from_type ("coin_blind",
   1541                                             &td.details.recoup.coin_blind),
   1542       TALER_PQ_RESULT_SPEC_AMOUNT ("amount",
   1543                                    &td.details.recoup.amount),
   1544       GNUNET_PQ_result_spec_timestamp ("recoup_timestamp",
   1545                                        &td.details.recoup.timestamp),
   1546       GNUNET_PQ_result_spec_auto_from_type (
   1547         "coin_pub",
   1548         &td.details.recoup.coin_pub),
   1549       GNUNET_PQ_result_spec_uint64 ("withdraw_id",
   1550                                     &td.details.recoup.withdraw_serial_id),
   1551       GNUNET_PQ_result_spec_uint32 ("coin_index",
   1552                                     &td.details.recoup.coin_index),
   1553       GNUNET_PQ_result_spec_end
   1554     };
   1555 
   1556     if (GNUNET_OK !=
   1557         GNUNET_PQ_extract_result (result,
   1558                                   rs,
   1559                                   i))
   1560     {
   1561       GNUNET_break (0);
   1562       ctx->error = true;
   1563       return;
   1564     }
   1565     ctx->cb (ctx->cb_cls,
   1566              &td);
   1567     GNUNET_PQ_cleanup_result (rs);
   1568   }
   1569 }
   1570 
   1571 
   1572 /**
   1573  * Function called with recoup_refresh table entries.
   1574  *
   1575  * @param cls closure
   1576  * @param result the postgres result
   1577  * @param num_results the number of results in @a result
   1578  */
   1579 static void
   1580 lrbt_cb_table_recoup_refresh (void *cls,
   1581                               PGresult *result,
   1582                               unsigned int num_results)
   1583 {
   1584   struct LookupRecordsByTableContext *ctx = cls;
   1585   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1586   struct TALER_EXCHANGEDB_TableData td = {
   1587     .table = TALER_EXCHANGEDB_RT_RECOUP_REFRESH
   1588   };
   1589 
   1590   for (unsigned int i = 0; i<num_results; i++)
   1591   {
   1592     struct GNUNET_PQ_ResultSpec rs[] = {
   1593       GNUNET_PQ_result_spec_uint64 (
   1594         "serial",
   1595         &td.serial),
   1596       GNUNET_PQ_result_spec_auto_from_type (
   1597         "coin_sig",
   1598         &td.details.recoup_refresh.coin_sig),
   1599       GNUNET_PQ_result_spec_auto_from_type (
   1600         "coin_blind",
   1601         &td.details.recoup_refresh.coin_blind),
   1602       TALER_PQ_RESULT_SPEC_AMOUNT (
   1603         "amount",
   1604         &td.details.recoup_refresh.amount),
   1605       GNUNET_PQ_result_spec_timestamp (
   1606         "recoup_timestamp",
   1607         &td.details.recoup_refresh.recoup_timestamp),
   1608       GNUNET_PQ_result_spec_uint64 (
   1609         "known_coin_id",
   1610         &td.details.recoup_refresh.known_coin_id),
   1611       GNUNET_PQ_result_spec_auto_from_type (
   1612         "coin_pub",
   1613         &td.details.recoup_refresh.coin_pub),
   1614       GNUNET_PQ_result_spec_uint64 (
   1615         "refresh_id",
   1616         &td.details.recoup_refresh.refresh_id),
   1617       GNUNET_PQ_result_spec_uint32 (
   1618         "coin_index",
   1619         &td.details.recoup_refresh.coin_index),
   1620       GNUNET_PQ_result_spec_end
   1621     };
   1622 
   1623     if (GNUNET_OK !=
   1624         GNUNET_PQ_extract_result (result,
   1625                                   rs,
   1626                                   i))
   1627     {
   1628       GNUNET_break (0);
   1629       ctx->error = true;
   1630       return;
   1631     }
   1632     ctx->cb (ctx->cb_cls,
   1633              &td);
   1634     GNUNET_PQ_cleanup_result (rs);
   1635   }
   1636 }
   1637 
   1638 
   1639 /**
   1640  * Function called with purse_requests table entries.
   1641  *
   1642  * @param cls closure
   1643  * @param result the postgres result
   1644  * @param num_results the number of results in @a result
   1645  */
   1646 static void
   1647 lrbt_cb_table_purse_requests (void *cls,
   1648                               PGresult *result,
   1649                               unsigned int num_results)
   1650 {
   1651   struct LookupRecordsByTableContext *ctx = cls;
   1652   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1653   struct TALER_EXCHANGEDB_TableData td = {
   1654     .table = TALER_EXCHANGEDB_RT_PURSE_REQUESTS
   1655   };
   1656 
   1657   for (unsigned int i = 0; i<num_results; i++)
   1658   {
   1659     struct GNUNET_PQ_ResultSpec rs[] = {
   1660       GNUNET_PQ_result_spec_uint64 (
   1661         "purse_requests_serial_id",
   1662         &td.serial),
   1663       GNUNET_PQ_result_spec_auto_from_type (
   1664         "purse_pub",
   1665         &td.details.purse_requests.purse_pub),
   1666       GNUNET_PQ_result_spec_auto_from_type (
   1667         "merge_pub",
   1668         &td.details.purse_requests.merge_pub),
   1669       GNUNET_PQ_result_spec_timestamp (
   1670         "purse_creation",
   1671         &td.details.purse_requests.purse_creation),
   1672       GNUNET_PQ_result_spec_timestamp (
   1673         "purse_expiration",
   1674         &td.details.purse_requests.purse_expiration),
   1675       GNUNET_PQ_result_spec_auto_from_type (
   1676         "h_contract_terms",
   1677         &td.details.purse_requests.h_contract_terms),
   1678       GNUNET_PQ_result_spec_uint32 (
   1679         "age_limit",
   1680         &td.details.purse_requests.age_limit),
   1681       GNUNET_PQ_result_spec_uint32 (
   1682         "flags",
   1683         &td.details.purse_requests.flags),
   1684       TALER_PQ_RESULT_SPEC_AMOUNT (
   1685         "amount_with_fee",
   1686         &td.details.purse_requests.amount_with_fee),
   1687       TALER_PQ_RESULT_SPEC_AMOUNT (
   1688         "purse_fee",
   1689         &td.details.purse_requests.purse_fee),
   1690       GNUNET_PQ_result_spec_auto_from_type (
   1691         "purse_sig",
   1692         &td.details.purse_requests.purse_sig),
   1693       GNUNET_PQ_result_spec_end
   1694     };
   1695 
   1696     if (GNUNET_OK !=
   1697         GNUNET_PQ_extract_result (result,
   1698                                   rs,
   1699                                   i))
   1700     {
   1701       GNUNET_break (0);
   1702       ctx->error = true;
   1703       return;
   1704     }
   1705     ctx->cb (ctx->cb_cls,
   1706              &td);
   1707     GNUNET_PQ_cleanup_result (rs);
   1708   }
   1709 }
   1710 
   1711 
   1712 /**
   1713  * Function called with purse_decision table entries.
   1714  *
   1715  * @param cls closure
   1716  * @param result the postgres result
   1717  * @param num_results the number of results in @a result
   1718  */
   1719 static void
   1720 lrbt_cb_table_purse_decision (void *cls,
   1721                               PGresult *result,
   1722                               unsigned int num_results)
   1723 {
   1724   struct LookupRecordsByTableContext *ctx = cls;
   1725   struct TALER_EXCHANGEDB_TableData td = {
   1726     .table = TALER_EXCHANGEDB_RT_PURSE_DECISION
   1727   };
   1728 
   1729   for (unsigned int i = 0; i<num_results; i++)
   1730   {
   1731     struct GNUNET_PQ_ResultSpec rs[] = {
   1732       GNUNET_PQ_result_spec_uint64 (
   1733         "purse_decision_serial_id",
   1734         &td.serial),
   1735       GNUNET_PQ_result_spec_auto_from_type (
   1736         "purse_pub",
   1737         &td.details.purse_decision.purse_pub),
   1738       GNUNET_PQ_result_spec_timestamp (
   1739         "action_timestamp",
   1740         &td.details.purse_decision.action_timestamp),
   1741       GNUNET_PQ_result_spec_bool (
   1742         "refunded",
   1743         &td.details.purse_decision.refunded),
   1744       GNUNET_PQ_result_spec_end
   1745     };
   1746 
   1747     if (GNUNET_OK !=
   1748         GNUNET_PQ_extract_result (result,
   1749                                   rs,
   1750                                   i))
   1751     {
   1752       GNUNET_break (0);
   1753       ctx->error = true;
   1754       return;
   1755     }
   1756     ctx->cb (ctx->cb_cls,
   1757              &td);
   1758     GNUNET_PQ_cleanup_result (rs);
   1759   }
   1760 }
   1761 
   1762 
   1763 /**
   1764  * Function called with purse_merges table entries.
   1765  *
   1766  * @param cls closure
   1767  * @param result the postgres result
   1768  * @param num_results the number of results in @a result
   1769  */
   1770 static void
   1771 lrbt_cb_table_purse_merges (void *cls,
   1772                             PGresult *result,
   1773                             unsigned int num_results)
   1774 {
   1775   struct LookupRecordsByTableContext *ctx = cls;
   1776   struct TALER_EXCHANGEDB_TableData td = {
   1777     .table = TALER_EXCHANGEDB_RT_PURSE_MERGES
   1778   };
   1779 
   1780   for (unsigned int i = 0; i<num_results; i++)
   1781   {
   1782     struct GNUNET_PQ_ResultSpec rs[] = {
   1783       GNUNET_PQ_result_spec_uint64 (
   1784         "purse_merge_request_serial_id",
   1785         &td.serial),
   1786       GNUNET_PQ_result_spec_uint64 (
   1787         "partner_serial_id",
   1788         &td.details.purse_merges.partner_serial_id),
   1789       GNUNET_PQ_result_spec_auto_from_type (
   1790         "reserve_pub",
   1791         &td.details.purse_merges.reserve_pub),
   1792       GNUNET_PQ_result_spec_auto_from_type (
   1793         "purse_pub",
   1794         &td.details.purse_merges.purse_pub),
   1795       GNUNET_PQ_result_spec_auto_from_type (
   1796         "merge_sig",
   1797         &td.details.purse_merges.merge_sig),
   1798       GNUNET_PQ_result_spec_timestamp (
   1799         "merge_timestamp",
   1800         &td.details.purse_merges.merge_timestamp),
   1801       GNUNET_PQ_result_spec_end
   1802     };
   1803 
   1804     if (GNUNET_OK !=
   1805         GNUNET_PQ_extract_result (result,
   1806                                   rs,
   1807                                   i))
   1808     {
   1809       GNUNET_break (0);
   1810       ctx->error = true;
   1811       return;
   1812     }
   1813     ctx->cb (ctx->cb_cls,
   1814              &td);
   1815     GNUNET_PQ_cleanup_result (rs);
   1816   }
   1817 }
   1818 
   1819 
   1820 /**
   1821  * Function called with purse_deposits table entries.
   1822  *
   1823  * @param cls closure
   1824  * @param result the postgres result
   1825  * @param num_results the number of results in @a result
   1826  */
   1827 static void
   1828 lrbt_cb_table_purse_deposits (void *cls,
   1829                               PGresult *result,
   1830                               unsigned int num_results)
   1831 {
   1832   struct LookupRecordsByTableContext *ctx = cls;
   1833   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1834   struct TALER_EXCHANGEDB_TableData td = {
   1835     .table = TALER_EXCHANGEDB_RT_PURSE_DEPOSITS
   1836   };
   1837 
   1838   for (unsigned int i = 0; i<num_results; i++)
   1839   {
   1840     struct GNUNET_PQ_ResultSpec rs[] = {
   1841       GNUNET_PQ_result_spec_uint64 (
   1842         "purse_deposit_serial_id",
   1843         &td.serial),
   1844       GNUNET_PQ_result_spec_uint64 (
   1845         "partner_serial_id",
   1846         &td.details.purse_deposits.partner_serial_id),
   1847       GNUNET_PQ_result_spec_auto_from_type (
   1848         "purse_pub",
   1849         &td.details.purse_deposits.purse_pub),
   1850       GNUNET_PQ_result_spec_auto_from_type (
   1851         "coin_pub",
   1852         &td.details.purse_deposits.coin_pub),
   1853       TALER_PQ_RESULT_SPEC_AMOUNT (
   1854         "amount_with_fee",
   1855         &td.details.purse_deposits.amount_with_fee),
   1856       GNUNET_PQ_result_spec_auto_from_type (
   1857         "coin_sig",
   1858         &td.details.purse_deposits.coin_sig),
   1859       GNUNET_PQ_result_spec_end
   1860     };
   1861 
   1862     if (GNUNET_OK !=
   1863         GNUNET_PQ_extract_result (result,
   1864                                   rs,
   1865                                   i))
   1866     {
   1867       GNUNET_break (0);
   1868       ctx->error = true;
   1869       return;
   1870     }
   1871     ctx->cb (ctx->cb_cls,
   1872              &td);
   1873     GNUNET_PQ_cleanup_result (rs);
   1874   }
   1875 }
   1876 
   1877 
   1878 /**
   1879  * Function called with account_merges table entries.
   1880  *
   1881  * @param cls closure
   1882  * @param result the postgres result
   1883  * @param num_results the number of results in @a result
   1884  */
   1885 static void
   1886 lrbt_cb_table_account_merges (void *cls,
   1887                               PGresult *result,
   1888                               unsigned int num_results)
   1889 {
   1890   struct LookupRecordsByTableContext *ctx = cls;
   1891   struct TALER_EXCHANGEDB_TableData td = {
   1892     .table = TALER_EXCHANGEDB_RT_ACCOUNT_MERGES
   1893   };
   1894 
   1895   for (unsigned int i = 0; i<num_results; i++)
   1896   {
   1897     struct GNUNET_PQ_ResultSpec rs[] = {
   1898       GNUNET_PQ_result_spec_uint64 (
   1899         "account_merge_request_serial_id",
   1900         &td.serial),
   1901       GNUNET_PQ_result_spec_auto_from_type (
   1902         "reserve_pub",
   1903         &td.details.account_merges.reserve_pub),
   1904       GNUNET_PQ_result_spec_auto_from_type (
   1905         "reserve_sig",
   1906         &td.details.account_merges.reserve_sig),
   1907       GNUNET_PQ_result_spec_auto_from_type (
   1908         "purse_pub",
   1909         &td.details.account_merges.purse_pub),
   1910       GNUNET_PQ_result_spec_auto_from_type (
   1911         "wallet_h_payto",
   1912         &td.details.account_merges.wallet_h_payto),
   1913       GNUNET_PQ_result_spec_end
   1914     };
   1915 
   1916     if (GNUNET_OK !=
   1917         GNUNET_PQ_extract_result (result,
   1918                                   rs,
   1919                                   i))
   1920     {
   1921       GNUNET_break (0);
   1922       ctx->error = true;
   1923       return;
   1924     }
   1925     ctx->cb (ctx->cb_cls,
   1926              &td);
   1927     GNUNET_PQ_cleanup_result (rs);
   1928   }
   1929 }
   1930 
   1931 
   1932 /**
   1933  * Function called with history_requests table entries.
   1934  *
   1935  * @param cls closure
   1936  * @param result the postgres result
   1937  * @param num_results the number of results in @a result
   1938  */
   1939 static void
   1940 lrbt_cb_table_history_requests (void *cls,
   1941                                 PGresult *result,
   1942                                 unsigned int num_results)
   1943 {
   1944   struct LookupRecordsByTableContext *ctx = cls;
   1945   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   1946   struct TALER_EXCHANGEDB_TableData td = {
   1947     .table = TALER_EXCHANGEDB_RT_HISTORY_REQUESTS
   1948   };
   1949 
   1950   for (unsigned int i = 0; i<num_results; i++)
   1951   {
   1952     struct GNUNET_PQ_ResultSpec rs[] = {
   1953       GNUNET_PQ_result_spec_uint64 (
   1954         "history_request_serial_id",
   1955         &td.serial),
   1956       GNUNET_PQ_result_spec_auto_from_type (
   1957         "reserve_pub",
   1958         &td.details.history_requests.reserve_pub),
   1959       GNUNET_PQ_result_spec_timestamp (
   1960         "request_timestamp",
   1961         &td.details.history_requests.request_timestamp),
   1962       GNUNET_PQ_result_spec_auto_from_type (
   1963         "reserve_sig",
   1964         &td.details.history_requests.reserve_sig),
   1965       TALER_PQ_RESULT_SPEC_AMOUNT (
   1966         "history_fee",
   1967         &td.details.history_requests.history_fee),
   1968       GNUNET_PQ_result_spec_end
   1969     };
   1970 
   1971     if (GNUNET_OK !=
   1972         GNUNET_PQ_extract_result (result,
   1973                                   rs,
   1974                                   i))
   1975     {
   1976       GNUNET_break (0);
   1977       ctx->error = true;
   1978       return;
   1979     }
   1980     ctx->cb (ctx->cb_cls,
   1981              &td);
   1982     GNUNET_PQ_cleanup_result (rs);
   1983   }
   1984 }
   1985 
   1986 
   1987 /**
   1988  * Function called with close_requests table entries.
   1989  *
   1990  * @param cls closure
   1991  * @param result the postgres result
   1992  * @param num_results the number of results in @a result
   1993  */
   1994 static void
   1995 lrbt_cb_table_close_requests (void *cls,
   1996                               PGresult *result,
   1997                               unsigned int num_results)
   1998 {
   1999   struct LookupRecordsByTableContext *ctx = cls;
   2000   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2001   struct TALER_EXCHANGEDB_TableData td = {
   2002     .table = TALER_EXCHANGEDB_RT_CLOSE_REQUESTS
   2003   };
   2004 
   2005   for (unsigned int i = 0; i<num_results; i++)
   2006   {
   2007     struct GNUNET_PQ_ResultSpec rs[] = {
   2008       GNUNET_PQ_result_spec_uint64 (
   2009         "close_request_serial_id",
   2010         &td.serial),
   2011       GNUNET_PQ_result_spec_auto_from_type (
   2012         "reserve_pub",
   2013         &td.details.close_requests.reserve_pub),
   2014       GNUNET_PQ_result_spec_timestamp (
   2015         "close_timestamp",
   2016         &td.details.close_requests.close_timestamp),
   2017       GNUNET_PQ_result_spec_auto_from_type (
   2018         "reserve_sig",
   2019         &td.details.close_requests.reserve_sig),
   2020       TALER_PQ_RESULT_SPEC_AMOUNT (
   2021         "close",
   2022         &td.details.close_requests.close),
   2023       TALER_PQ_RESULT_SPEC_AMOUNT (
   2024         "close_fee",
   2025         &td.details.close_requests.close_fee),
   2026       GNUNET_PQ_result_spec_string (
   2027         "payto_uri",
   2028         &td.details.close_requests.payto_uri.full_payto),
   2029       GNUNET_PQ_result_spec_end
   2030     };
   2031 
   2032     if (GNUNET_OK !=
   2033         GNUNET_PQ_extract_result (result,
   2034                                   rs,
   2035                                   i))
   2036     {
   2037       GNUNET_break (0);
   2038       ctx->error = true;
   2039       return;
   2040     }
   2041     ctx->cb (ctx->cb_cls,
   2042              &td);
   2043     GNUNET_PQ_cleanup_result (rs);
   2044   }
   2045 }
   2046 
   2047 
   2048 /**
   2049  * Function called with wads_out table entries.
   2050  *
   2051  * @param cls closure
   2052  * @param result the postgres result
   2053  * @param num_results the number of results in @a result
   2054  */
   2055 static void
   2056 lrbt_cb_table_wads_out (void *cls,
   2057                         PGresult *result,
   2058                         unsigned int num_results)
   2059 {
   2060   struct LookupRecordsByTableContext *ctx = cls;
   2061   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2062   struct TALER_EXCHANGEDB_TableData td = {
   2063     .table = TALER_EXCHANGEDB_RT_WADS_OUT
   2064   };
   2065 
   2066   for (unsigned int i = 0; i<num_results; i++)
   2067   {
   2068     struct GNUNET_PQ_ResultSpec rs[] = {
   2069       GNUNET_PQ_result_spec_uint64 (
   2070         "wad_out_serial_id",
   2071         &td.serial),
   2072       GNUNET_PQ_result_spec_auto_from_type (
   2073         "wad_id",
   2074         &td.details.wads_out.wad_id),
   2075       GNUNET_PQ_result_spec_uint64 (
   2076         "partner_serial_id",
   2077         &td.details.wads_out.partner_serial_id),
   2078       TALER_PQ_RESULT_SPEC_AMOUNT (
   2079         "amount",
   2080         &td.details.wads_out.amount),
   2081       GNUNET_PQ_result_spec_timestamp (
   2082         "execution_time",
   2083         &td.details.wads_out.execution_time),
   2084       GNUNET_PQ_result_spec_end
   2085     };
   2086 
   2087     if (GNUNET_OK !=
   2088         GNUNET_PQ_extract_result (result,
   2089                                   rs,
   2090                                   i))
   2091     {
   2092       GNUNET_break (0);
   2093       ctx->error = true;
   2094       return;
   2095     }
   2096     ctx->cb (ctx->cb_cls,
   2097              &td);
   2098     GNUNET_PQ_cleanup_result (rs);
   2099   }
   2100 }
   2101 
   2102 
   2103 /**
   2104  * Function called with wads_out_entries table entries.
   2105  *
   2106  * @param cls closure
   2107  * @param result the postgres result
   2108  * @param num_results the number of results in @a result
   2109  */
   2110 static void
   2111 lrbt_cb_table_wads_out_entries (void *cls,
   2112                                 PGresult *result,
   2113                                 unsigned int num_results)
   2114 {
   2115   struct LookupRecordsByTableContext *ctx = cls;
   2116   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2117   struct TALER_EXCHANGEDB_TableData td = {
   2118     .table = TALER_EXCHANGEDB_RT_WADS_OUT_ENTRIES
   2119   };
   2120 
   2121   for (unsigned int i = 0; i<num_results; i++)
   2122   {
   2123     struct GNUNET_PQ_ResultSpec rs[] = {
   2124       GNUNET_PQ_result_spec_uint64 (
   2125         "wad_out_entry_serial_id",
   2126         &td.serial),
   2127       GNUNET_PQ_result_spec_uint64 (
   2128         "wad_out_serial_id",
   2129         &td.details.wads_out_entries.wad_out_serial_id),
   2130       GNUNET_PQ_result_spec_auto_from_type (
   2131         "reserve_pub",
   2132         &td.details.wads_out_entries.reserve_pub),
   2133       GNUNET_PQ_result_spec_auto_from_type (
   2134         "purse_pub",
   2135         &td.details.wads_out_entries.purse_pub),
   2136       GNUNET_PQ_result_spec_auto_from_type (
   2137         "h_contract",
   2138         &td.details.wads_out_entries.h_contract),
   2139       GNUNET_PQ_result_spec_timestamp (
   2140         "purse_expiration",
   2141         &td.details.wads_out_entries.purse_expiration),
   2142       GNUNET_PQ_result_spec_timestamp (
   2143         "merge_timestamp",
   2144         &td.details.wads_out_entries.merge_timestamp),
   2145       TALER_PQ_RESULT_SPEC_AMOUNT (
   2146         "amount_with_fee",
   2147         &td.details.wads_out_entries.amount_with_fee),
   2148       TALER_PQ_RESULT_SPEC_AMOUNT (
   2149         "wad_fee",
   2150         &td.details.wads_out_entries.wad_fee),
   2151       TALER_PQ_RESULT_SPEC_AMOUNT (
   2152         "deposit_fees",
   2153         &td.details.wads_out_entries.deposit_fees),
   2154       GNUNET_PQ_result_spec_auto_from_type (
   2155         "reserve_sig",
   2156         &td.details.wads_out_entries.reserve_sig),
   2157       GNUNET_PQ_result_spec_auto_from_type (
   2158         "purse_sig",
   2159         &td.details.wads_out_entries.purse_sig),
   2160       GNUNET_PQ_result_spec_end
   2161     };
   2162 
   2163     if (GNUNET_OK !=
   2164         GNUNET_PQ_extract_result (result,
   2165                                   rs,
   2166                                   i))
   2167     {
   2168       GNUNET_break (0);
   2169       ctx->error = true;
   2170       return;
   2171     }
   2172     ctx->cb (ctx->cb_cls,
   2173              &td);
   2174     GNUNET_PQ_cleanup_result (rs);
   2175   }
   2176 }
   2177 
   2178 
   2179 /**
   2180  * Function called with wads_in table entries.
   2181  *
   2182  * @param cls closure
   2183  * @param result the postgres result
   2184  * @param num_results the number of results in @a result
   2185  */
   2186 static void
   2187 lrbt_cb_table_wads_in (void *cls,
   2188                        PGresult *result,
   2189                        unsigned int num_results)
   2190 {
   2191   struct LookupRecordsByTableContext *ctx = cls;
   2192   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2193   struct TALER_EXCHANGEDB_TableData td = {
   2194     .table = TALER_EXCHANGEDB_RT_WADS_IN
   2195   };
   2196 
   2197   for (unsigned int i = 0; i<num_results; i++)
   2198   {
   2199     struct GNUNET_PQ_ResultSpec rs[] = {
   2200       GNUNET_PQ_result_spec_uint64 (
   2201         "wad_in_serial_id",
   2202         &td.serial),
   2203       GNUNET_PQ_result_spec_auto_from_type (
   2204         "wad_id",
   2205         &td.details.wads_in.wad_id),
   2206       GNUNET_PQ_result_spec_string (
   2207         "origin_exchange_url",
   2208         &td.details.wads_in.origin_exchange_url),
   2209       TALER_PQ_RESULT_SPEC_AMOUNT (
   2210         "amount",
   2211         &td.details.wads_in.amount),
   2212       GNUNET_PQ_result_spec_timestamp (
   2213         "arrival_time",
   2214         &td.details.wads_in.arrival_time),
   2215       GNUNET_PQ_result_spec_end
   2216     };
   2217 
   2218     if (GNUNET_OK !=
   2219         GNUNET_PQ_extract_result (result,
   2220                                   rs,
   2221                                   i))
   2222     {
   2223       GNUNET_break (0);
   2224       ctx->error = true;
   2225       return;
   2226     }
   2227     ctx->cb (ctx->cb_cls,
   2228              &td);
   2229     GNUNET_PQ_cleanup_result (rs);
   2230   }
   2231 }
   2232 
   2233 
   2234 /**
   2235  * Function called with wads_in_entries table entries.
   2236  *
   2237  * @param cls closure
   2238  * @param result the postgres result
   2239  * @param num_results the number of results in @a result
   2240  */
   2241 static void
   2242 lrbt_cb_table_wads_in_entries (void *cls,
   2243                                PGresult *result,
   2244                                unsigned int num_results)
   2245 {
   2246   struct LookupRecordsByTableContext *ctx = cls;
   2247   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2248   struct TALER_EXCHANGEDB_TableData td = {
   2249     .table = TALER_EXCHANGEDB_RT_WADS_IN_ENTRIES
   2250   };
   2251 
   2252   for (unsigned int i = 0; i<num_results; i++)
   2253   {
   2254     struct GNUNET_PQ_ResultSpec rs[] = {
   2255       GNUNET_PQ_result_spec_uint64 (
   2256         "wad_in_entry_serial_id",
   2257         &td.serial),
   2258       GNUNET_PQ_result_spec_uint64 (
   2259         "wad_in_serial_id",
   2260         &td.details.wads_in_entries.wad_in_serial_id),
   2261       GNUNET_PQ_result_spec_auto_from_type (
   2262         "reserve_pub",
   2263         &td.details.wads_in_entries.reserve_pub),
   2264       GNUNET_PQ_result_spec_auto_from_type (
   2265         "purse_pub",
   2266         &td.details.wads_in_entries.purse_pub),
   2267       GNUNET_PQ_result_spec_auto_from_type (
   2268         "h_contract",
   2269         &td.details.wads_in_entries.h_contract),
   2270       GNUNET_PQ_result_spec_timestamp (
   2271         "purse_expiration",
   2272         &td.details.wads_in_entries.purse_expiration),
   2273       GNUNET_PQ_result_spec_timestamp (
   2274         "merge_timestamp",
   2275         &td.details.wads_in_entries.merge_timestamp),
   2276       TALER_PQ_RESULT_SPEC_AMOUNT (
   2277         "amount_with_fee",
   2278         &td.details.wads_in_entries.amount_with_fee),
   2279       TALER_PQ_RESULT_SPEC_AMOUNT (
   2280         "wad_fee",
   2281         &td.details.wads_in_entries.wad_fee),
   2282       TALER_PQ_RESULT_SPEC_AMOUNT (
   2283         "deposit_fees",
   2284         &td.details.wads_in_entries.deposit_fees),
   2285       GNUNET_PQ_result_spec_auto_from_type (
   2286         "reserve_sig",
   2287         &td.details.wads_in_entries.reserve_sig),
   2288       GNUNET_PQ_result_spec_auto_from_type (
   2289         "purse_sig",
   2290         &td.details.wads_in_entries.purse_sig),
   2291       GNUNET_PQ_result_spec_end
   2292     };
   2293 
   2294     if (GNUNET_OK !=
   2295         GNUNET_PQ_extract_result (result,
   2296                                   rs,
   2297                                   i))
   2298     {
   2299       GNUNET_break (0);
   2300       ctx->error = true;
   2301       return;
   2302     }
   2303     ctx->cb (ctx->cb_cls,
   2304              &td);
   2305     GNUNET_PQ_cleanup_result (rs);
   2306   }
   2307 }
   2308 
   2309 
   2310 /**
   2311  * Function called with profit_drains table entries.
   2312  *
   2313  * @param cls closure
   2314  * @param result the postgres result
   2315  * @param num_results the number of results in @a result
   2316  */
   2317 static void
   2318 lrbt_cb_table_profit_drains (void *cls,
   2319                              PGresult *result,
   2320                              unsigned int num_results)
   2321 {
   2322   struct LookupRecordsByTableContext *ctx = cls;
   2323   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2324   struct TALER_EXCHANGEDB_TableData td = {
   2325     .table = TALER_EXCHANGEDB_RT_PROFIT_DRAINS
   2326   };
   2327 
   2328   for (unsigned int i = 0; i<num_results; i++)
   2329   {
   2330     struct GNUNET_PQ_ResultSpec rs[] = {
   2331       GNUNET_PQ_result_spec_uint64 (
   2332         "profit_drain_serial_id",
   2333         &td.serial),
   2334       GNUNET_PQ_result_spec_auto_from_type (
   2335         "wtid",
   2336         &td.details.profit_drains.wtid),
   2337       GNUNET_PQ_result_spec_string (
   2338         "account_section",
   2339         &td.details.profit_drains.account_section),
   2340       GNUNET_PQ_result_spec_string (
   2341         "payto_uri",
   2342         &td.details.profit_drains.payto_uri.full_payto),
   2343       GNUNET_PQ_result_spec_timestamp (
   2344         "trigger_date",
   2345         &td.details.profit_drains.trigger_date),
   2346       TALER_PQ_RESULT_SPEC_AMOUNT (
   2347         "amount",
   2348         &td.details.profit_drains.amount),
   2349       GNUNET_PQ_result_spec_auto_from_type (
   2350         "master_sig",
   2351         &td.details.profit_drains.master_sig),
   2352       GNUNET_PQ_result_spec_end
   2353     };
   2354 
   2355     if (GNUNET_OK !=
   2356         GNUNET_PQ_extract_result (result,
   2357                                   rs,
   2358                                   i))
   2359     {
   2360       GNUNET_break (0);
   2361       ctx->error = true;
   2362       return;
   2363     }
   2364     ctx->cb (ctx->cb_cls,
   2365              &td);
   2366     GNUNET_PQ_cleanup_result (rs);
   2367   }
   2368 }
   2369 
   2370 
   2371 /**
   2372  * Function called with aml_staff table entries.
   2373  *
   2374  * @param cls closure
   2375  * @param result the postgres result
   2376  * @param num_results the number of results in @a result
   2377  */
   2378 static void
   2379 lrbt_cb_table_aml_staff (void *cls,
   2380                          PGresult *result,
   2381                          unsigned int num_results)
   2382 {
   2383   struct LookupRecordsByTableContext *ctx = cls;
   2384   struct TALER_EXCHANGEDB_TableData td = {
   2385     .table = TALER_EXCHANGEDB_RT_AML_STAFF
   2386   };
   2387 
   2388   for (unsigned int i = 0; i<num_results; i++)
   2389   {
   2390     struct GNUNET_PQ_ResultSpec rs[] = {
   2391       GNUNET_PQ_result_spec_uint64 (
   2392         "aml_staff_uuid",
   2393         &td.serial),
   2394       GNUNET_PQ_result_spec_auto_from_type (
   2395         "decider_pub",
   2396         &td.details.aml_staff.decider_pub),
   2397       GNUNET_PQ_result_spec_auto_from_type (
   2398         "master_sig",
   2399         &td.details.aml_staff.master_sig),
   2400       GNUNET_PQ_result_spec_string (
   2401         "decider_name",
   2402         &td.details.aml_staff.decider_name),
   2403       GNUNET_PQ_result_spec_bool (
   2404         "is_active",
   2405         &td.details.aml_staff.is_active),
   2406       GNUNET_PQ_result_spec_bool (
   2407         "read_only",
   2408         &td.details.aml_staff.read_only),
   2409       GNUNET_PQ_result_spec_timestamp (
   2410         "last_change",
   2411         &td.details.aml_staff.last_change),
   2412       GNUNET_PQ_result_spec_end
   2413     };
   2414 
   2415     if (GNUNET_OK !=
   2416         GNUNET_PQ_extract_result (result,
   2417                                   rs,
   2418                                   i))
   2419     {
   2420       GNUNET_break (0);
   2421       ctx->error = true;
   2422       return;
   2423     }
   2424     ctx->cb (ctx->cb_cls,
   2425              &td);
   2426     GNUNET_PQ_cleanup_result (rs);
   2427   }
   2428 }
   2429 
   2430 
   2431 /**
   2432  * Function called with purse_deletion table entries.
   2433  *
   2434  * @param cls closure
   2435  * @param result the postgres result
   2436  * @param num_results the number of results in @a result
   2437  */
   2438 static void
   2439 lrbt_cb_table_purse_deletion (void *cls,
   2440                               PGresult *result,
   2441                               unsigned int num_results)
   2442 {
   2443   struct LookupRecordsByTableContext *ctx = cls;
   2444   struct TALER_EXCHANGEDB_TableData td = {
   2445     .table = TALER_EXCHANGEDB_RT_PURSE_DELETION
   2446   };
   2447 
   2448   for (unsigned int i = 0; i<num_results; i++)
   2449   {
   2450     struct GNUNET_PQ_ResultSpec rs[] = {
   2451       GNUNET_PQ_result_spec_uint64 (
   2452         "purse_deletion_serial_id",
   2453         &td.serial),
   2454       GNUNET_PQ_result_spec_auto_from_type (
   2455         "purse_sig",
   2456         &td.details.purse_deletion.purse_sig),
   2457       GNUNET_PQ_result_spec_auto_from_type (
   2458         "purse_pub",
   2459         &td.details.purse_deletion.purse_pub),
   2460       GNUNET_PQ_result_spec_end
   2461     };
   2462 
   2463     if (GNUNET_OK !=
   2464         GNUNET_PQ_extract_result (result,
   2465                                   rs,
   2466                                   i))
   2467     {
   2468       GNUNET_break (0);
   2469       ctx->error = true;
   2470       return;
   2471     }
   2472     ctx->cb (ctx->cb_cls,
   2473              &td);
   2474     GNUNET_PQ_cleanup_result (rs);
   2475   }
   2476 }
   2477 
   2478 
   2479 /**
   2480  * Function called with withdraw table entries.
   2481  *
   2482  * @param cls closure
   2483  * @param result the postgres result
   2484  * @param num_results the number of results in @a result
   2485  */
   2486 static void
   2487 lrbt_cb_table_withdraw (void *cls,
   2488                         PGresult *result,
   2489                         unsigned int num_results)
   2490 {
   2491   struct LookupRecordsByTableContext *ctx = cls;
   2492   struct TALER_EXCHANGEDB_PostgresContext *pg = ctx->pg;
   2493   struct TALER_EXCHANGEDB_TableData td = {
   2494     .table = TALER_EXCHANGEDB_RT_WITHDRAW
   2495   };
   2496 
   2497   for (unsigned int i = 0; i<num_results; i++)
   2498   {
   2499     bool no_max_age;
   2500     bool no_noreveal_index;
   2501     bool no_selected_h;
   2502     bool no_cs_r_values;
   2503     bool no_cs_r_choices;
   2504     size_t num_sigs;
   2505     struct GNUNET_PQ_ResultSpec rs[] = {
   2506       GNUNET_PQ_result_spec_uint64 (
   2507         "withdraw_id",
   2508         &td.serial),
   2509       GNUNET_PQ_result_spec_auto_from_type (
   2510         "planchets_h",
   2511         &td.details.withdraw.planchets_h),
   2512       GNUNET_PQ_result_spec_timestamp (
   2513         "execution_date",
   2514         &td.details.withdraw.execution_date),
   2515       TALER_PQ_RESULT_SPEC_AMOUNT (
   2516         "amount_with_fee",
   2517         &td.details.withdraw.amount_with_fee),
   2518       GNUNET_PQ_result_spec_auto_from_type (
   2519         "reserve_pub",
   2520         &td.details.withdraw.reserve_pub),
   2521       GNUNET_PQ_result_spec_auto_from_type (
   2522         "reserve_sig",
   2523         &td.details.withdraw.reserve_sig),
   2524       GNUNET_PQ_result_spec_allow_null (
   2525         GNUNET_PQ_result_spec_uint16 (
   2526           "max_age",
   2527           &td.details.withdraw.max_age),
   2528         &no_max_age),
   2529       GNUNET_PQ_result_spec_allow_null (
   2530         GNUNET_PQ_result_spec_uint16 (
   2531           "noreveal_index",
   2532           &td.details.withdraw.noreveal_index),
   2533         &no_noreveal_index),
   2534       GNUNET_PQ_result_spec_allow_null (
   2535         GNUNET_PQ_result_spec_auto_from_type (
   2536           "selected_h",
   2537           &td.details.withdraw.selected_h),
   2538         &no_selected_h),
   2539       GNUNET_PQ_result_spec_allow_null (
   2540         GNUNET_PQ_result_spec_auto_from_type (
   2541           "blinding_seed",
   2542           &td.details.withdraw.blinding_seed),
   2543         &td.details.withdraw.no_blinding_seed),
   2544       GNUNET_PQ_result_spec_allow_null (
   2545         TALER_PQ_result_spec_array_cs_r_pub (
   2546           pg->conn,
   2547           "cs_r_values",
   2548           &td.details.withdraw.num_cs_r_values,
   2549           &td.details.withdraw.cs_r_values),
   2550         &no_cs_r_values),
   2551       GNUNET_PQ_result_spec_allow_null (
   2552         GNUNET_PQ_result_spec_uint64 (
   2553           "cs_r_choices",
   2554           &td.details.withdraw.cs_r_choices),
   2555         &no_cs_r_choices),
   2556       GNUNET_PQ_result_spec_array_uint64 (
   2557         pg->conn,
   2558         "denom_serials",
   2559         &td.details.withdraw.num_coins,
   2560         &td.details.withdraw.denom_serials),
   2561       TALER_PQ_result_spec_array_blinded_denom_sig (
   2562         pg->conn,
   2563         "denom_sigs",
   2564         &num_sigs,
   2565         &td.details.withdraw.denom_sigs),
   2566       GNUNET_PQ_result_spec_end
   2567     };
   2568 
   2569     if (GNUNET_OK !=
   2570         GNUNET_PQ_extract_result (result,
   2571                                   rs,
   2572                                   i))
   2573     {
   2574       GNUNET_break (0);
   2575       ctx->error = true;
   2576       GNUNET_PQ_cleanup_result (rs);
   2577       return;
   2578     }
   2579     if (num_sigs != td.details.withdraw.num_coins)
   2580     {
   2581       GNUNET_break (0);
   2582       ctx->error = true;
   2583       GNUNET_PQ_cleanup_result (rs);
   2584       return;
   2585     }
   2586     if (no_max_age != no_noreveal_index)
   2587     {
   2588       GNUNET_break (0);
   2589       ctx->error = true;
   2590       GNUNET_PQ_cleanup_result (rs);
   2591       return;
   2592     }
   2593     if (no_max_age != no_selected_h)
   2594     {
   2595       GNUNET_break (0);
   2596       ctx->error = true;
   2597       GNUNET_PQ_cleanup_result (rs);
   2598       return;
   2599     }
   2600     if (no_cs_r_values != no_cs_r_choices)
   2601     {
   2602       GNUNET_break (0);
   2603       ctx->error = true;
   2604       GNUNET_PQ_cleanup_result (rs);
   2605       return;
   2606     }
   2607     if (no_cs_r_values != td.details.withdraw.no_blinding_seed)
   2608     {
   2609       GNUNET_break (0);
   2610       ctx->error = true;
   2611       GNUNET_PQ_cleanup_result (rs);
   2612       return;
   2613     }
   2614     td.details.withdraw.age_proof_required = ! no_max_age;
   2615     ctx->cb (ctx->cb_cls,
   2616              &td);
   2617     GNUNET_PQ_cleanup_result (rs);
   2618   }
   2619 }
   2620 
   2621 
   2622 /**
   2623  * Function called with legitimization_measures table entries.
   2624  *
   2625  * @param cls closure
   2626  * @param result the postgres result
   2627  * @param num_results the number of results in @a result
   2628  */
   2629 static void
   2630 lrbt_cb_table_legitimization_measures (void *cls,
   2631                                        PGresult *result,
   2632                                        unsigned int num_results)
   2633 {
   2634   struct LookupRecordsByTableContext *ctx = cls;
   2635   struct TALER_EXCHANGEDB_TableData td = {
   2636     .table = TALER_EXCHANGEDB_RT_LEGITIMIZATION_MEASURES
   2637   };
   2638 
   2639   for (unsigned int i = 0; i<num_results; i++)
   2640   {
   2641     struct GNUNET_PQ_ResultSpec rs[] = {
   2642       GNUNET_PQ_result_spec_uint64 ("serial",
   2643                                     &td.serial),
   2644       GNUNET_PQ_result_spec_auto_from_type (
   2645         "access_token",
   2646         &td.details.legitimization_measures.target_token),
   2647       GNUNET_PQ_result_spec_absolute_time (
   2648         "start_time",
   2649         &td.details.legitimization_measures.start_time),
   2650       TALER_PQ_result_spec_json (
   2651         "jmeasures",
   2652         &td.details.legitimization_measures.measures),
   2653       GNUNET_PQ_result_spec_uint32 (
   2654         "display_priority",
   2655         &td.details.legitimization_measures.display_priority),
   2656       GNUNET_PQ_result_spec_end
   2657     };
   2658 
   2659     if (GNUNET_OK !=
   2660         GNUNET_PQ_extract_result (result,
   2661                                   rs,
   2662                                   i))
   2663     {
   2664       GNUNET_break (0);
   2665       ctx->error = true;
   2666       return;
   2667     }
   2668     ctx->cb (ctx->cb_cls,
   2669              &td);
   2670     GNUNET_PQ_cleanup_result (rs);
   2671   }
   2672 }
   2673 
   2674 
   2675 /**
   2676  * Function called with legitimization_outcomes table entries.
   2677  *
   2678  * @param cls closure
   2679  * @param result the postgres result
   2680  * @param num_results the number of results in @a result
   2681  */
   2682 static void
   2683 lrbt_cb_table_legitimization_outcomes (void *cls,
   2684                                        PGresult *result,
   2685                                        unsigned int num_results)
   2686 {
   2687   struct LookupRecordsByTableContext *ctx = cls;
   2688   struct TALER_EXCHANGEDB_TableData td = {
   2689     .table = TALER_EXCHANGEDB_RT_LEGITIMIZATION_OUTCOMES
   2690   };
   2691 
   2692   for (unsigned int i = 0; i<num_results; i++)
   2693   {
   2694     struct GNUNET_PQ_ResultSpec rs[] = {
   2695       GNUNET_PQ_result_spec_uint64 ("serial",
   2696                                     &td.serial),
   2697       GNUNET_PQ_result_spec_auto_from_type (
   2698         "h_payto",
   2699         &td.details.legitimization_outcomes.h_payto),
   2700       GNUNET_PQ_result_spec_timestamp (
   2701         "decision_time",
   2702         &td.details.legitimization_outcomes.decision_time),
   2703       GNUNET_PQ_result_spec_timestamp (
   2704         "expiration_time",
   2705         &td.details.legitimization_outcomes.expiration_time),
   2706       GNUNET_PQ_result_spec_allow_null (
   2707         TALER_PQ_result_spec_json (
   2708           "jproperties",
   2709           &td.details.legitimization_outcomes.properties),
   2710         NULL),
   2711       GNUNET_PQ_result_spec_bool (
   2712         "to_investigate",
   2713         &td.details.legitimization_outcomes.to_investigate),
   2714       TALER_PQ_result_spec_json (
   2715         "jnew_rules",
   2716         &td.details.legitimization_outcomes.new_rules),
   2717       GNUNET_PQ_result_spec_end
   2718     };
   2719 
   2720     if (GNUNET_OK !=
   2721         GNUNET_PQ_extract_result (result,
   2722                                   rs,
   2723                                   i))
   2724     {
   2725       GNUNET_break (0);
   2726       ctx->error = true;
   2727       return;
   2728     }
   2729     ctx->cb (ctx->cb_cls,
   2730              &td);
   2731     GNUNET_PQ_cleanup_result (rs);
   2732   }
   2733 }
   2734 
   2735 
   2736 /**
   2737  * Function called with legitimization_processes table entries.
   2738  *
   2739  * @param cls closure
   2740  * @param result the postgres result
   2741  * @param num_results the number of results in @a result
   2742  */
   2743 static void
   2744 lrbt_cb_table_legitimization_processes (void *cls,
   2745                                         PGresult *result,
   2746                                         unsigned int num_results)
   2747 {
   2748   struct LookupRecordsByTableContext *ctx = cls;
   2749   struct TALER_EXCHANGEDB_TableData td = {
   2750     .table = TALER_EXCHANGEDB_RT_LEGITIMIZATION_PROCESSES
   2751   };
   2752 
   2753   for (unsigned int i = 0; i<num_results; i++)
   2754   {
   2755     struct GNUNET_PQ_ResultSpec rs[] = {
   2756       GNUNET_PQ_result_spec_uint64 ("serial",
   2757                                     &td.serial),
   2758       GNUNET_PQ_result_spec_auto_from_type (
   2759         "h_payto",
   2760         &td.details.legitimization_processes.h_payto),
   2761       GNUNET_PQ_result_spec_absolute_time (
   2762         "start_time",
   2763         &td.details.legitimization_processes.start_time),
   2764       GNUNET_PQ_result_spec_timestamp (
   2765         "expiration_time",
   2766         &td.details.legitimization_processes.expiration_time),
   2767       GNUNET_PQ_result_spec_uint64 (
   2768         "legitimization_measure_serial_id",
   2769         &td.details.legitimization_processes.legitimization_measure_serial_id),
   2770       GNUNET_PQ_result_spec_uint32 (
   2771         "measure_index",
   2772         &td.details.legitimization_processes.measure_index),
   2773       GNUNET_PQ_result_spec_string (
   2774         "provider_name",
   2775         &td.details.legitimization_processes.provider_name),
   2776       GNUNET_PQ_result_spec_allow_null (
   2777         GNUNET_PQ_result_spec_string (
   2778           "provider_user_id",
   2779           &td.details.legitimization_processes.provider_user_id),
   2780         NULL),
   2781       GNUNET_PQ_result_spec_allow_null (
   2782         GNUNET_PQ_result_spec_string (
   2783           "provider_legitimization_id",
   2784           &td.details.legitimization_processes.provider_legitimization_id),
   2785         NULL),
   2786       GNUNET_PQ_result_spec_allow_null (
   2787         GNUNET_PQ_result_spec_string (
   2788           "redirect_url",
   2789           &td.details.legitimization_processes.redirect_url),
   2790         NULL),
   2791       GNUNET_PQ_result_spec_end
   2792     };
   2793 
   2794     if (GNUNET_OK !=
   2795         GNUNET_PQ_extract_result (result,
   2796                                   rs,
   2797                                   i))
   2798     {
   2799       GNUNET_break (0);
   2800       ctx->error = true;
   2801       return;
   2802     }
   2803     ctx->cb (ctx->cb_cls,
   2804              &td);
   2805     GNUNET_PQ_cleanup_result (rs);
   2806   }
   2807 }
   2808 
   2809 
   2810 /**
   2811  * Function called with kyc_attributes table entries.
   2812  *
   2813  * @param cls closure
   2814  * @param result the postgres result
   2815  * @param num_results the number of results in @a result
   2816  */
   2817 static void
   2818 lrbt_cb_table_kyc_attributes (void *cls,
   2819                               PGresult *result,
   2820                               unsigned int num_results)
   2821 {
   2822   struct LookupRecordsByTableContext *ctx = cls;
   2823   struct TALER_EXCHANGEDB_TableData td = {
   2824     .table = TALER_EXCHANGEDB_RT_KYC_ATTRIBUTES
   2825   };
   2826 
   2827   for (unsigned int i = 0; i<num_results; i++)
   2828   {
   2829     struct GNUNET_PQ_ResultSpec rs[] = {
   2830       GNUNET_PQ_result_spec_uint64 (
   2831         "kyc_attributes_serial_id",
   2832         &td.serial),
   2833       GNUNET_PQ_result_spec_auto_from_type (
   2834         "h_payto",
   2835         &td.details.kyc_attributes.h_payto),
   2836       GNUNET_PQ_result_spec_uint64 (
   2837         "legitimization_serial",
   2838         &td.details.kyc_attributes.legitimization_serial),
   2839       GNUNET_PQ_result_spec_timestamp (
   2840         "collection_time",
   2841         &td.details.kyc_attributes.collection_time),
   2842       GNUNET_PQ_result_spec_timestamp (
   2843         "expiration_time",
   2844         &td.details.kyc_attributes.expiration_time),
   2845       GNUNET_PQ_result_spec_allow_null (
   2846         GNUNET_PQ_result_spec_string (
   2847           "form_name",
   2848           &td.details.kyc_attributes.form_name),
   2849         NULL),
   2850       GNUNET_PQ_result_spec_bool (
   2851         "by_aml_officer",
   2852         &td.details.kyc_attributes.by_aml_officer),
   2853       GNUNET_PQ_result_spec_variable_size (
   2854         "encrypted_attributes",
   2855         &td.details.kyc_attributes.encrypted_attributes,
   2856         &td.details.kyc_attributes.encrypted_attributes_size),
   2857       GNUNET_PQ_result_spec_end
   2858     };
   2859 
   2860     if (GNUNET_OK !=
   2861         GNUNET_PQ_extract_result (result,
   2862                                   rs,
   2863                                   i))
   2864     {
   2865       GNUNET_break (0);
   2866       ctx->error = true;
   2867       return;
   2868     }
   2869     ctx->cb (ctx->cb_cls,
   2870              &td);
   2871     GNUNET_PQ_cleanup_result (rs);
   2872   }
   2873 }
   2874 
   2875 
   2876 /**
   2877  * Function called with aml_history table entries.
   2878  *
   2879  * @param cls closure
   2880  * @param result the postgres result
   2881  * @param num_results the number of results in @a result
   2882  */
   2883 static void
   2884 lrbt_cb_table_aml_history (void *cls,
   2885                            PGresult *result,
   2886                            unsigned int num_results)
   2887 {
   2888   struct LookupRecordsByTableContext *ctx = cls;
   2889   struct TALER_EXCHANGEDB_TableData td = {
   2890     .table = TALER_EXCHANGEDB_RT_AML_HISTORY
   2891   };
   2892 
   2893   for (unsigned int i = 0; i<num_results; i++)
   2894   {
   2895     struct GNUNET_PQ_ResultSpec rs[] = {
   2896       GNUNET_PQ_result_spec_uint64 (
   2897         "aml_history_serial_id",
   2898         &td.serial),
   2899       GNUNET_PQ_result_spec_auto_from_type (
   2900         "h_payto",
   2901         &td.details.aml_history.h_payto),
   2902       GNUNET_PQ_result_spec_uint64 (
   2903         "outcome_serial_id",
   2904         &td.details.aml_history.outcome_serial_id),
   2905       GNUNET_PQ_result_spec_string (
   2906         "justification",
   2907         &td.details.aml_history.justification),
   2908       GNUNET_PQ_result_spec_auto_from_type (
   2909         "decider_pub",
   2910         &td.details.aml_history.decider_pub),
   2911       GNUNET_PQ_result_spec_auto_from_type (
   2912         "decider_sig",
   2913         &td.details.aml_history.decider_sig),
   2914       GNUNET_PQ_result_spec_allow_null (
   2915         GNUNET_PQ_result_spec_auto_from_type (
   2916           "kyc_attributes_hash",
   2917           &td.details.aml_history.kyc_attributes_hash),
   2918         &td.details.aml_history.no_kyc_attributes_hash),
   2919       GNUNET_PQ_result_spec_allow_null (
   2920         GNUNET_PQ_result_spec_uint64 (
   2921           "kyc_attributes_serial_id",
   2922           &td.details.aml_history.kyc_attributes_serial_id),
   2923         &td.details.aml_history.no_kyc_attributes_serial_id),
   2924       GNUNET_PQ_result_spec_end
   2925     };
   2926 
   2927     if (GNUNET_OK !=
   2928         GNUNET_PQ_extract_result (result,
   2929                                   rs,
   2930                                   i))
   2931     {
   2932       GNUNET_break (0);
   2933       ctx->error = true;
   2934       return;
   2935     }
   2936     ctx->cb (ctx->cb_cls,
   2937              &td);
   2938     GNUNET_PQ_cleanup_result (rs);
   2939   }
   2940 }
   2941 
   2942 
   2943 /**
   2944  * Function called with kyc_events table entries.
   2945  *
   2946  * @param cls closure
   2947  * @param result the postgres result
   2948  * @param num_results the number of results in @a result
   2949  */
   2950 static void
   2951 lrbt_cb_table_kyc_events (void *cls,
   2952                           PGresult *result,
   2953                           unsigned int num_results)
   2954 {
   2955   struct LookupRecordsByTableContext *ctx = cls;
   2956   struct TALER_EXCHANGEDB_TableData td = {
   2957     .table = TALER_EXCHANGEDB_RT_KYC_EVENTS
   2958   };
   2959 
   2960   for (unsigned int i = 0; i<num_results; i++)
   2961   {
   2962     struct GNUNET_PQ_ResultSpec rs[] = {
   2963       GNUNET_PQ_result_spec_uint64 (
   2964         "serial",
   2965         &td.serial),
   2966       GNUNET_PQ_result_spec_timestamp (
   2967         "event_timestamp",
   2968         &td.details.kyc_events.event_timestamp),
   2969       GNUNET_PQ_result_spec_string (
   2970         "event_type",
   2971         &td.details.kyc_events.event_type),
   2972       GNUNET_PQ_result_spec_end
   2973     };
   2974 
   2975     if (GNUNET_OK !=
   2976         GNUNET_PQ_extract_result (result,
   2977                                   rs,
   2978                                   i))
   2979     {
   2980       GNUNET_break (0);
   2981       ctx->error = true;
   2982       return;
   2983     }
   2984     ctx->cb (ctx->cb_cls,
   2985              &td);
   2986     GNUNET_PQ_cleanup_result (rs);
   2987   }
   2988 }
   2989 
   2990 
   2991 /**
   2992  * Assign statement to @a n and PREPARE
   2993  * @a sql under name @a n.
   2994  */
   2995 #define XPREPARE(n,sql) \
   2996         statement = n;        \
   2997         PREPARE (pg, n, sql);
   2998 
   2999 
   3000 enum GNUNET_DB_QueryStatus
   3001 TALER_EXCHANGEDB_iterate_records_by_table (
   3002   struct TALER_EXCHANGEDB_PostgresContext *pg,
   3003   enum TALER_EXCHANGEDB_ReplicatedTable table,
   3004   uint64_t serial,
   3005   TALER_EXCHANGEDB_ReplicationCallback cb,
   3006   void *cb_cls)
   3007 {
   3008   struct GNUNET_PQ_QueryParam params[] = {
   3009     GNUNET_PQ_query_param_uint64 (&serial),
   3010     GNUNET_PQ_query_param_end
   3011   };
   3012   struct LookupRecordsByTableContext ctx = {
   3013     .pg = pg,
   3014     .cb = cb,
   3015     .cb_cls = cb_cls
   3016   };
   3017   GNUNET_PQ_PostgresResultHandler rh = NULL;
   3018   const char *statement = NULL;
   3019   enum GNUNET_DB_QueryStatus qs;
   3020 
   3021   switch (table)
   3022   {
   3023   case TALER_EXCHANGEDB_RT_DENOMINATIONS:
   3024     XPREPARE ("select_above_serial_by_table_denominations",
   3025               "SELECT"
   3026               " denominations_serial AS serial"
   3027               ",denom_type"
   3028               ",denom_pub"
   3029               ",master_sig"
   3030               ",valid_from"
   3031               ",expire_withdraw"
   3032               ",expire_deposit"
   3033               ",expire_legal"
   3034               ",coin"
   3035               ",fee_withdraw"
   3036               ",fee_deposit"
   3037               ",fee_refresh"
   3038               ",fee_refund"
   3039               ",age_mask"
   3040               " FROM denominations"
   3041               " WHERE denominations_serial > $1"
   3042               " ORDER BY denominations_serial ASC;");
   3043     rh = &lrbt_cb_table_denominations;
   3044     break;
   3045   case TALER_EXCHANGEDB_RT_DENOMINATION_REVOCATIONS:
   3046     XPREPARE ("select_above_serial_by_table_denomination_revocations",
   3047               "SELECT"
   3048               " denom_revocations_serial_id AS serial"
   3049               ",master_sig"
   3050               ",denominations_serial"
   3051               " FROM denomination_revocations"
   3052               " WHERE denom_revocations_serial_id > $1"
   3053               " ORDER BY denom_revocations_serial_id ASC;");
   3054     rh = &lrbt_cb_table_denomination_revocations;
   3055     break;
   3056   case TALER_EXCHANGEDB_RT_WIRE_TARGETS:
   3057     XPREPARE ("select_above_serial_by_table_wire_targets",
   3058               "SELECT"
   3059               " wire_target_serial_id AS serial"
   3060               ",payto_uri"
   3061               " FROM wire_targets"
   3062               " WHERE wire_target_serial_id > $1"
   3063               " ORDER BY wire_target_serial_id ASC;");
   3064     rh = &lrbt_cb_table_wire_targets;
   3065     break;
   3066   case TALER_EXCHANGEDB_RT_KYC_TARGETS:
   3067     XPREPARE ("select_above_serial_by_table_kyc_targets",
   3068               "SELECT"
   3069               " kyc_target_serial_id AS serial"
   3070               ",h_normalized_payto"
   3071               ",access_token"
   3072               ",target_pub"
   3073               ",is_wallet"
   3074               " FROM kyc_targets"
   3075               " WHERE kyc_target_serial_id > $1"
   3076               " ORDER BY kyc_target_serial_id ASC;");
   3077     rh = &lrbt_cb_table_kyc_targets;
   3078     break;
   3079   case TALER_EXCHANGEDB_RT_RESERVES:
   3080     XPREPARE ("select_above_serial_by_table_reserves",
   3081               "SELECT"
   3082               " reserve_uuid AS serial"
   3083               ",reserve_pub"
   3084               ",expiration_date"
   3085               ",gc_date"
   3086               " FROM reserves"
   3087               " WHERE reserve_uuid > $1"
   3088               " ORDER BY reserve_uuid ASC;");
   3089     rh = &lrbt_cb_table_reserves;
   3090     break;
   3091   case TALER_EXCHANGEDB_RT_RESERVES_IN:
   3092     XPREPARE ("select_above_serial_by_table_reserves_in",
   3093               "SELECT"
   3094               " reserve_in_serial_id AS serial"
   3095               ",reserve_pub"
   3096               ",wire_reference"
   3097               ",credit"
   3098               ",wire_source_h_payto"
   3099               ",exchange_account_section"
   3100               ",execution_date"
   3101               " FROM reserves_in"
   3102               " WHERE reserve_in_serial_id > $1"
   3103               " ORDER BY reserve_in_serial_id ASC;");
   3104     rh = &lrbt_cb_table_reserves_in;
   3105     break;
   3106   case TALER_EXCHANGEDB_RT_KYCAUTHS_IN:
   3107     XPREPARE ("select_above_serial_by_table_kycauth_in",
   3108               "SELECT"
   3109               " kycauth_in_serial_id AS serial"
   3110               ",account_pub"
   3111               ",wire_reference"
   3112               ",credit"
   3113               ",wire_source_h_payto"
   3114               ",exchange_account_section"
   3115               ",execution_date"
   3116               " FROM kycauths_in"
   3117               " WHERE kycauth_in_serial_id > $1"
   3118               " ORDER BY kycauth_in_serial_id ASC;");
   3119     rh = &lrbt_cb_table_kycauth_in;
   3120     break;
   3121   case TALER_EXCHANGEDB_RT_RESERVES_CLOSE:
   3122     XPREPARE ("select_above_serial_by_table_reserves_close",
   3123               "SELECT"
   3124               " close_uuid AS serial"
   3125               ",reserve_pub"
   3126               ",execution_date"
   3127               ",wtid"
   3128               ",wire_target_h_payto"
   3129               ",amount"
   3130               ",closing_fee"
   3131               " FROM reserves_close"
   3132               " WHERE close_uuid > $1"
   3133               " ORDER BY close_uuid ASC;");
   3134     rh = &lrbt_cb_table_reserves_close;
   3135     break;
   3136   case TALER_EXCHANGEDB_RT_RESERVES_OPEN_REQUESTS:
   3137     XPREPARE ("select_above_serial_by_table_reserves_open_requests",
   3138               "SELECT"
   3139               " open_request_uuid AS serial"
   3140               ",reserve_pub"
   3141               ",request_timestamp"
   3142               ",expiration_date"
   3143               ",reserve_sig"
   3144               ",reserve_payment"
   3145               ",requested_purse_limit"
   3146               " FROM reserves_open_requests"
   3147               " WHERE open_request_uuid > $1"
   3148               " ORDER BY open_request_uuid ASC;");
   3149     rh = &lrbt_cb_table_reserves_open_requests;
   3150     break;
   3151   case TALER_EXCHANGEDB_RT_RESERVES_OPEN_DEPOSITS:
   3152     XPREPARE ("select_above_serial_by_table_reserves_open_deposits",
   3153               "SELECT"
   3154               " reserve_open_deposit_uuid AS serial"
   3155               ",reserve_sig"
   3156               ",reserve_pub"
   3157               ",coin_pub"
   3158               ",coin_sig"
   3159               ",contribution"
   3160               " FROM reserves_open_deposits"
   3161               " WHERE reserve_open_deposit_uuid > $1"
   3162               " ORDER BY reserve_open_deposit_uuid ASC;");
   3163     rh = &lrbt_cb_table_reserves_open_deposits;
   3164     break;
   3165   case TALER_EXCHANGEDB_RT_AUDITORS:
   3166     XPREPARE ("select_above_serial_by_table_auditors",
   3167               "SELECT"
   3168               " auditor_uuid AS serial"
   3169               ",auditor_pub"
   3170               ",auditor_name"
   3171               ",auditor_url"
   3172               ",is_active"
   3173               ",last_change"
   3174               " FROM auditors"
   3175               " WHERE auditor_uuid > $1"
   3176               " ORDER BY auditor_uuid ASC;");
   3177     rh = &lrbt_cb_table_auditors;
   3178     break;
   3179   case TALER_EXCHANGEDB_RT_AUDITOR_DENOM_SIGS:
   3180     XPREPARE ("select_above_serial_by_table_auditor_denom_sigs",
   3181               "SELECT"
   3182               " auditor_denom_serial AS serial"
   3183               ",auditor_uuid"
   3184               ",denominations_serial"
   3185               ",auditor_sig"
   3186               " FROM auditor_denom_sigs"
   3187               " WHERE auditor_denom_serial > $1"
   3188               " ORDER BY auditor_denom_serial ASC;");
   3189     rh = &lrbt_cb_table_auditor_denom_sigs;
   3190     break;
   3191   case TALER_EXCHANGEDB_RT_EXCHANGE_SIGN_KEYS:
   3192     XPREPARE ("select_above_serial_by_table_exchange_sign_keys",
   3193               "SELECT"
   3194               " esk_serial AS serial"
   3195               ",exchange_pub"
   3196               ",master_sig"
   3197               ",valid_from"
   3198               ",expire_sign"
   3199               ",expire_legal"
   3200               " FROM exchange_sign_keys"
   3201               " WHERE esk_serial > $1"
   3202               " ORDER BY esk_serial ASC;");
   3203     rh = &lrbt_cb_table_exchange_sign_keys;
   3204     break;
   3205   case TALER_EXCHANGEDB_RT_SIGNKEY_REVOCATIONS:
   3206     XPREPARE ("select_above_serial_by_table_signkey_revocations",
   3207               "SELECT"
   3208               " signkey_revocations_serial_id AS serial"
   3209               ",esk_serial"
   3210               ",master_sig"
   3211               " FROM signkey_revocations"
   3212               " WHERE signkey_revocations_serial_id > $1"
   3213               " ORDER BY signkey_revocations_serial_id ASC;");
   3214     rh = &lrbt_cb_table_signkey_revocations;
   3215     break;
   3216   case TALER_EXCHANGEDB_RT_KNOWN_COINS:
   3217     XPREPARE ("select_above_serial_by_table_known_coins",
   3218               "SELECT"
   3219               " known_coin_id AS serial"
   3220               ",coin_pub"
   3221               ",denom_sig"
   3222               ",denominations_serial"
   3223               " FROM known_coins"
   3224               " WHERE known_coin_id > $1"
   3225               " ORDER BY known_coin_id ASC;");
   3226     rh = &lrbt_cb_table_known_coins;
   3227     break;
   3228   case TALER_EXCHANGEDB_RT_REFRESH:
   3229     XPREPARE ("select_above_serial_by_table_refresh",
   3230               "SELECT"
   3231               " refresh_id AS serial"
   3232               ",rc"
   3233               ",execution_date"
   3234               ",amount_with_fee"
   3235               ",old_coin_pub"
   3236               ",old_coin_sig"
   3237               ",refresh_seed"
   3238               ",noreveal_index"
   3239               ",planchets_h"
   3240               ",selected_h"
   3241               ",blinding_seed"
   3242               ",cs_r_values"
   3243               ",cs_r_choices"
   3244               ",denom_serials"
   3245               ",denom_sigs"
   3246               ",transfer_pubs"
   3247               ",revealed"
   3248               ",rc_version"
   3249               " FROM refresh"
   3250               " WHERE refresh_id > $1"
   3251               " ORDER BY refresh_id ASC;");
   3252     rh = &lrbt_cb_table_refresh;
   3253     break;
   3254   case TALER_EXCHANGEDB_RT_BATCH_DEPOSITS:
   3255     XPREPARE ("select_above_serial_by_table_batch_deposits",
   3256               "SELECT"
   3257               " batch_deposit_serial_id AS serial"
   3258               ",shard"
   3259               ",merchant_pub"
   3260               ",wallet_timestamp"
   3261               ",exchange_timestamp"
   3262               ",refund_deadline"
   3263               ",wire_deadline"
   3264               ",h_contract_terms"
   3265               ",wallet_data_hash"
   3266               ",wire_salt"
   3267               ",wire_target_h_payto"
   3268               ",total_amount"
   3269               ",total_without_fee"
   3270               ",merchant_sig"
   3271               ",done"
   3272               " FROM batch_deposits"
   3273               " WHERE batch_deposit_serial_id > $1"
   3274               " ORDER BY batch_deposit_serial_id ASC;");
   3275     rh = &lrbt_cb_table_batch_deposits;
   3276     break;
   3277   case TALER_EXCHANGEDB_RT_COIN_DEPOSITS:
   3278     XPREPARE ("select_above_serial_by_table_coin_deposits",
   3279               "SELECT"
   3280               " coin_deposit_serial_id AS serial"
   3281               ",batch_deposit_serial_id"
   3282               ",coin_pub"
   3283               ",coin_sig"
   3284               ",amount_with_fee"
   3285               " FROM coin_deposits"
   3286               " WHERE coin_deposit_serial_id > $1"
   3287               " ORDER BY coin_deposit_serial_id ASC;");
   3288     rh = &lrbt_cb_table_coin_deposits;
   3289     break;
   3290   case TALER_EXCHANGEDB_RT_REFUNDS:
   3291     XPREPARE ("select_above_serial_by_table_refunds",
   3292               "SELECT"
   3293               " refund_serial_id AS serial"
   3294               ",coin_pub"
   3295               ",merchant_sig"
   3296               ",rtransaction_id"
   3297               ",amount_with_fee"
   3298               ",batch_deposit_serial_id"
   3299               " FROM refunds"
   3300               " WHERE refund_serial_id > $1"
   3301               " ORDER BY refund_serial_id ASC;");
   3302     rh = &lrbt_cb_table_refunds;
   3303     break;
   3304   case TALER_EXCHANGEDB_RT_WIRE_OUT:
   3305     XPREPARE ("select_above_serial_by_table_wire_out",
   3306               "SELECT"
   3307               " wireout_uuid AS serial"
   3308               ",execution_date"
   3309               ",wtid_raw"
   3310               ",wire_target_h_payto"
   3311               ",exchange_account_section"
   3312               ",amount"
   3313               " FROM wire_out"
   3314               " WHERE wireout_uuid > $1"
   3315               " ORDER BY wireout_uuid ASC;");
   3316     rh = &lrbt_cb_table_wire_out;
   3317     break;
   3318   case TALER_EXCHANGEDB_RT_AGGREGATION_TRACKING:
   3319     XPREPARE ("select_above_serial_by_table_aggregation_tracking",
   3320               "SELECT"
   3321               " aggregation_serial_id AS serial"
   3322               ",batch_deposit_serial_id"
   3323               ",wtid_raw"
   3324               " FROM aggregation_tracking"
   3325               " WHERE aggregation_serial_id > $1"
   3326               " ORDER BY aggregation_serial_id ASC;");
   3327     rh = &lrbt_cb_table_aggregation_tracking;
   3328     break;
   3329   case TALER_EXCHANGEDB_RT_AGGREGATION_DEFERRALS:
   3330     XPREPARE ("select_above_serial_by_table_aggregation_deferrals",
   3331               "SELECT"
   3332               " aggregation_deferral_serial_id AS serial"
   3333               ",batch_deposit_serial_id"
   3334               ",wtid_raw"
   3335               ",wire_target_h_payto"
   3336               ",amount"
   3337               ",deferral_reason"
   3338               ",legitimization_requirement_serial_id"
   3339               ",deferral_time"
   3340               " FROM aggregation_deferrals"
   3341               " WHERE aggregation_deferral_serial_id > $1"
   3342               " ORDER BY aggregation_deferral_serial_id ASC;");
   3343     rh = &lrbt_cb_table_aggregation_deferrals;
   3344     break;
   3345   case TALER_EXCHANGEDB_RT_WIRE_FEE:
   3346     XPREPARE ("select_above_serial_by_table_wire_fee",
   3347               "SELECT"
   3348               " wire_fee_serial AS serial"
   3349               ",wire_method"
   3350               ",start_date"
   3351               ",end_date"
   3352               ",wire_fee"
   3353               ",closing_fee"
   3354               ",master_sig"
   3355               " FROM wire_fee"
   3356               " WHERE wire_fee_serial > $1"
   3357               " ORDER BY wire_fee_serial ASC;");
   3358     rh = &lrbt_cb_table_wire_fee;
   3359     break;
   3360   case TALER_EXCHANGEDB_RT_GLOBAL_FEE:
   3361     XPREPARE ("select_above_serial_by_table_global_fee",
   3362               "SELECT"
   3363               " global_fee_serial AS serial"
   3364               ",start_date"
   3365               ",end_date"
   3366               ",history_fee"
   3367               ",account_fee"
   3368               ",purse_fee"
   3369               ",purse_timeout"
   3370               ",history_expiration"
   3371               ",purse_account_limit"
   3372               ",master_sig"
   3373               " FROM global_fee"
   3374               " WHERE global_fee_serial > $1"
   3375               " ORDER BY global_fee_serial ASC;");
   3376     rh = &lrbt_cb_table_global_fee;
   3377     break;
   3378   case TALER_EXCHANGEDB_RT_RECOUP:
   3379     XPREPARE ("select_above_serial_by_table_recoup",
   3380               "SELECT"
   3381               " recoup_uuid AS serial"
   3382               ",coin_sig"
   3383               ",coin_blind"
   3384               ",amount"
   3385               ",recoup_timestamp"
   3386               ",coin_pub"
   3387               ",withdraw_id"
   3388               ",coin_index"
   3389               " FROM recoup"
   3390               " WHERE recoup_uuid > $1"
   3391               " ORDER BY recoup_uuid ASC;");
   3392     rh = &lrbt_cb_table_recoup;
   3393     break;
   3394   case TALER_EXCHANGEDB_RT_RECOUP_REFRESH:
   3395     XPREPARE ("select_above_serial_by_table_recoup_refresh",
   3396               "SELECT"
   3397               " recoup_refresh_uuid AS serial"
   3398               ",coin_sig"
   3399               ",coin_blind"
   3400               ",amount"
   3401               ",recoup_timestamp"
   3402               ",coin_pub"
   3403               ",known_coin_id"
   3404               ",refresh_id"
   3405               ",coin_index"
   3406               " FROM recoup_refresh"
   3407               " WHERE recoup_refresh_uuid > $1"
   3408               " ORDER BY recoup_refresh_uuid ASC;");
   3409     rh = &lrbt_cb_table_recoup_refresh;
   3410     break;
   3411   case TALER_EXCHANGEDB_RT_PURSE_REQUESTS:
   3412     XPREPARE ("select_above_serial_by_table_purse_requests",
   3413               "SELECT"
   3414               " purse_requests_serial_id"
   3415               ",purse_pub"
   3416               ",merge_pub"
   3417               ",purse_creation"
   3418               ",purse_expiration"
   3419               ",h_contract_terms"
   3420               ",age_limit"
   3421               ",flags"
   3422               ",amount_with_fee"
   3423               ",purse_fee"
   3424               ",purse_sig"
   3425               " FROM purse_requests"
   3426               " WHERE purse_requests_serial_id > $1"
   3427               " ORDER BY purse_requests_serial_id ASC;");
   3428     rh = &lrbt_cb_table_purse_requests;
   3429     break;
   3430   case TALER_EXCHANGEDB_RT_PURSE_DECISION:
   3431     XPREPARE ("select_above_serial_by_table_purse_decision",
   3432               "SELECT"
   3433               " purse_decision_serial_id"
   3434               ",purse_pub"
   3435               ",action_timestamp"
   3436               ",refunded"
   3437               " FROM purse_decision"
   3438               " WHERE purse_decision_serial_id > $1"
   3439               " ORDER BY purse_decision_serial_id ASC;");
   3440     rh = &lrbt_cb_table_purse_decision;
   3441     break;
   3442   case TALER_EXCHANGEDB_RT_PURSE_MERGES:
   3443     XPREPARE ("select_above_serial_by_table_purse_merges",
   3444               "SELECT"
   3445               " purse_merge_request_serial_id"
   3446               ",partner_serial_id"
   3447               ",reserve_pub"
   3448               ",purse_pub"
   3449               ",merge_sig"
   3450               ",merge_timestamp"
   3451               " FROM purse_merges"
   3452               " WHERE purse_merge_request_serial_id > $1"
   3453               " ORDER BY purse_merge_request_serial_id ASC;");
   3454     rh = &lrbt_cb_table_purse_merges;
   3455     break;
   3456   case TALER_EXCHANGEDB_RT_PURSE_DEPOSITS:
   3457     XPREPARE ("select_above_serial_by_table_purse_deposits",
   3458               "SELECT"
   3459               " purse_deposit_serial_id"
   3460               ",partner_serial_id"
   3461               ",purse_pub"
   3462               ",coin_pub"
   3463               ",amount_with_fee"
   3464               ",coin_sig"
   3465               " FROM purse_deposits"
   3466               " WHERE purse_deposit_serial_id > $1"
   3467               " ORDER BY purse_deposit_serial_id ASC;");
   3468     rh = &lrbt_cb_table_purse_deposits;
   3469     break;
   3470   case TALER_EXCHANGEDB_RT_ACCOUNT_MERGES:
   3471     XPREPARE ("select_above_serial_by_table_account_merges",
   3472               "SELECT"
   3473               " account_merge_request_serial_id"
   3474               ",reserve_pub"
   3475               ",reserve_sig"
   3476               ",purse_pub"
   3477               ",wallet_h_payto"
   3478               " FROM account_merges"
   3479               " WHERE account_merge_request_serial_id > $1"
   3480               " ORDER BY account_merge_request_serial_id ASC;");
   3481     rh = &lrbt_cb_table_account_merges;
   3482     break;
   3483   case TALER_EXCHANGEDB_RT_HISTORY_REQUESTS:
   3484     XPREPARE ("select_above_serial_by_table_history_requests",
   3485               "SELECT"
   3486               " history_request_serial_id"
   3487               ",reserve_pub"
   3488               ",request_timestamp"
   3489               ",reserve_sig"
   3490               ",history_fee"
   3491               " FROM history_requests"
   3492               " WHERE history_request_serial_id > $1"
   3493               " ORDER BY history_request_serial_id ASC;");
   3494     rh = &lrbt_cb_table_history_requests;
   3495     break;
   3496   case TALER_EXCHANGEDB_RT_CLOSE_REQUESTS:
   3497     XPREPARE ("select_above_serial_by_table_close_requests",
   3498               "SELECT"
   3499               " close_request_serial_id"
   3500               ",reserve_pub"
   3501               ",close_timestamp"
   3502               ",reserve_sig"
   3503               ",close"
   3504               ",close_fee"
   3505               ",payto_uri"
   3506               " FROM close_requests"
   3507               " WHERE close_request_serial_id > $1"
   3508               " ORDER BY close_request_serial_id ASC;");
   3509     rh = &lrbt_cb_table_close_requests;
   3510     break;
   3511   case TALER_EXCHANGEDB_RT_WADS_OUT:
   3512     XPREPARE ("select_above_serial_by_table_wads_out",
   3513               "SELECT"
   3514               " wad_out_serial_id"
   3515               ",wad_id"
   3516               ",partner_serial_id"
   3517               ",amount"
   3518               ",execution_time"
   3519               " FROM wads_out"
   3520               " WHERE wad_out_serial_id > $1"
   3521               " ORDER BY wad_out_serial_id ASC;");
   3522     rh = &lrbt_cb_table_wads_out;
   3523     break;
   3524   case TALER_EXCHANGEDB_RT_WADS_OUT_ENTRIES:
   3525     XPREPARE ("select_above_serial_by_table_wads_out_entries",
   3526               "SELECT"
   3527               " wad_out_entry_serial_id"
   3528               ",wad_out_serial_id"
   3529               ",reserve_pub"
   3530               ",purse_pub"
   3531               ",h_contract"
   3532               ",purse_expiration"
   3533               ",merge_timestamp"
   3534               ",amount_with_fee"
   3535               ",wad_fee"
   3536               ",deposit_fees"
   3537               ",reserve_sig"
   3538               ",purse_sig"
   3539               " FROM wad_out_entries"
   3540               " WHERE wad_out_entry_serial_id > $1"
   3541               " ORDER BY wad_out_entry_serial_id ASC;");
   3542     rh = &lrbt_cb_table_wads_out_entries;
   3543     break;
   3544   case TALER_EXCHANGEDB_RT_WADS_IN:
   3545     XPREPARE ("select_above_serial_by_table_wads_in",
   3546               "SELECT"
   3547               " wad_in_serial_id"
   3548               ",wad_id"
   3549               ",origin_exchange_url"
   3550               ",amount"
   3551               ",arrival_time"
   3552               " FROM wads_in"
   3553               " WHERE wad_in_serial_id > $1"
   3554               " ORDER BY wad_in_serial_id ASC;");
   3555     rh = &lrbt_cb_table_wads_in;
   3556     break;
   3557   case TALER_EXCHANGEDB_RT_WADS_IN_ENTRIES:
   3558     XPREPARE ("select_above_serial_by_table_wads_in_entries",
   3559               "SELECT"
   3560               " wad_in_entry_serial_id"
   3561               ",wad_in_serial_id"
   3562               ",reserve_pub"
   3563               ",purse_pub"
   3564               ",h_contract"
   3565               ",purse_expiration"
   3566               ",merge_timestamp"
   3567               ",amount_with_fee"
   3568               ",wad_fee"
   3569               ",deposit_fees"
   3570               ",reserve_sig"
   3571               ",purse_sig"
   3572               " FROM wad_in_entries"
   3573               " WHERE wad_in_entry_serial_id > $1"
   3574               " ORDER BY wad_in_entry_serial_id ASC;");
   3575     rh = &lrbt_cb_table_wads_in_entries;
   3576     break;
   3577   case TALER_EXCHANGEDB_RT_PROFIT_DRAINS:
   3578     XPREPARE ("select_above_serial_by_table_profit_drains",
   3579               "SELECT"
   3580               " profit_drain_serial_id"
   3581               ",wtid"
   3582               ",account_section"
   3583               ",payto_uri"
   3584               ",trigger_date"
   3585               ",amount"
   3586               ",master_sig"
   3587               " FROM profit_drains"
   3588               " WHERE profit_drain_serial_id > $1"
   3589               " ORDER BY profit_drain_serial_id ASC;");
   3590     rh = &lrbt_cb_table_profit_drains;
   3591     break;
   3592 
   3593   case TALER_EXCHANGEDB_RT_AML_STAFF:
   3594     XPREPARE ("select_above_serial_by_table_aml_staff",
   3595               "SELECT"
   3596               " aml_staff_uuid"
   3597               ",decider_pub"
   3598               ",master_sig"
   3599               ",decider_name"
   3600               ",is_active"
   3601               ",read_only"
   3602               ",last_change"
   3603               " FROM aml_staff"
   3604               " WHERE aml_staff_uuid > $1"
   3605               " ORDER BY aml_staff_uuid ASC;");
   3606     rh = &lrbt_cb_table_aml_staff;
   3607     break;
   3608   case TALER_EXCHANGEDB_RT_PURSE_DELETION:
   3609     XPREPARE ("select_above_serial_by_table_purse_deletion",
   3610               "SELECT"
   3611               " purse_deletion_serial_id"
   3612               ",purse_pub"
   3613               ",purse_sig"
   3614               " FROM purse_deletion"
   3615               " WHERE purse_deletion_serial_id > $1"
   3616               " ORDER BY purse_deletion_serial_id ASC;");
   3617     rh = &lrbt_cb_table_purse_deletion;
   3618     break;
   3619   case TALER_EXCHANGEDB_RT_WITHDRAW:
   3620     XPREPARE ("select_above_serial_by_table_withdraw",
   3621               "SELECT"
   3622               " withdraw_id"
   3623               ",planchets_h"
   3624               ",execution_date"
   3625               ",amount_with_fee"
   3626               ",reserve_pub"
   3627               ",reserve_sig"
   3628               ",max_age"
   3629               ",noreveal_index"
   3630               ",selected_h"
   3631               ",blinding_seed"
   3632               ",cs_r_values"
   3633               ",cs_r_choices"
   3634               ",denom_serials"
   3635               ",denom_sigs"
   3636               " FROM withdraw"
   3637               " WHERE withdraw_id > $1"
   3638               " ORDER BY withdraw_id ASC;");
   3639     rh = &lrbt_cb_table_withdraw;
   3640     break;
   3641   case TALER_EXCHANGEDB_RT_LEGITIMIZATION_MEASURES:
   3642     XPREPARE ("select_above_serial_by_table_legitimization_measures",
   3643               "SELECT"
   3644               " legitimization_measure_serial_id AS serial"
   3645               ",access_token"
   3646               ",start_time"
   3647               ",jmeasures::TEXT"
   3648               ",display_priority"
   3649               " FROM legitimization_measures"
   3650               " WHERE legitimization_measure_serial_id > $1"
   3651               " ORDER BY legitimization_measure_serial_id ASC;");
   3652     rh = &lrbt_cb_table_legitimization_measures;
   3653     break;
   3654   case TALER_EXCHANGEDB_RT_LEGITIMIZATION_OUTCOMES:
   3655     XPREPARE ("select_above_serial_by_table_legitimization_outcomes",
   3656               "SELECT"
   3657               " outcome_serial_id AS serial"
   3658               ",h_payto"
   3659               ",decision_time"
   3660               ",expiration_time"
   3661               ",jproperties::TEXT"
   3662               ",to_investigate"
   3663               ",jnew_rules::TEXT"
   3664               " FROM legitimization_outcomes"
   3665               " WHERE outcome_serial_id > $1"
   3666               " ORDER BY outcome_serial_id ASC;");
   3667     rh = &lrbt_cb_table_legitimization_outcomes;
   3668     break;
   3669   case TALER_EXCHANGEDB_RT_LEGITIMIZATION_PROCESSES:
   3670     XPREPARE ("select_above_serial_by_table_legitimization_processes",
   3671               "SELECT"
   3672               " legitimization_process_serial_id AS serial"
   3673               ",h_payto"
   3674               ",start_time"
   3675               ",expiration_time"
   3676               ",legitimization_measure_serial_id"
   3677               ",measure_index"
   3678               ",provider_name"
   3679               ",provider_user_id"
   3680               ",provider_legitimization_id"
   3681               ",redirect_url"
   3682               " FROM legitimization_processes"
   3683               " WHERE legitimization_process_serial_id > $1"
   3684               " ORDER BY legitimization_process_serial_id ASC;");
   3685     rh = &lrbt_cb_table_legitimization_processes;
   3686     break;
   3687   case TALER_EXCHANGEDB_RT_KYC_ATTRIBUTES:
   3688     XPREPARE ("select_above_serial_by_table_kyc_attributes",
   3689               "SELECT"
   3690               " kyc_attributes_serial_id"
   3691               ",h_payto"
   3692               ",legitimization_serial"
   3693               ",collection_time"
   3694               ",expiration_time"
   3695               ",form_name"
   3696               ",by_aml_officer"
   3697               ",encrypted_attributes"
   3698               " FROM kyc_attributes"
   3699               " WHERE kyc_attributes_serial_id > $1"
   3700               " ORDER BY kyc_attributes_serial_id ASC;");
   3701     rh = &lrbt_cb_table_kyc_attributes;
   3702     break;
   3703   case TALER_EXCHANGEDB_RT_AML_HISTORY:
   3704     XPREPARE ("select_above_serial_by_table_aml_history",
   3705               "SELECT"
   3706               " aml_history_serial_id"
   3707               ",h_payto"
   3708               ",outcome_serial_id"
   3709               ",justification"
   3710               ",decider_pub"
   3711               ",decider_sig"
   3712               ",kyc_attributes_hash"
   3713               ",kyc_attributes_serial_id"
   3714               " FROM aml_history"
   3715               " WHERE aml_history_serial_id > $1"
   3716               " ORDER BY aml_history_serial_id ASC;");
   3717     rh = &lrbt_cb_table_aml_history;
   3718     break;
   3719   case TALER_EXCHANGEDB_RT_KYC_EVENTS:
   3720     XPREPARE ("select_above_serial_by_table_kyc_events",
   3721               "SELECT"
   3722               " kyc_event_serial_id AS serial"
   3723               ",event_timestamp"
   3724               ",event_type"
   3725               " FROM kyc_events"
   3726               " WHERE kyc_event_serial_id > $1"
   3727               " ORDER BY kyc_event_serial_id ASC;");
   3728     rh = &lrbt_cb_table_kyc_events;
   3729     break;
   3730   }
   3731   if (NULL == rh)
   3732   {
   3733     GNUNET_break (0);
   3734     return GNUNET_DB_STATUS_HARD_ERROR;
   3735   }
   3736 
   3737   qs = GNUNET_PQ_eval_prepared_multi_select (pg->conn,
   3738                                              statement,
   3739                                              params,
   3740                                              rh,
   3741                                              &ctx);
   3742   if (qs < 0)
   3743   {
   3744     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
   3745                 "Failed to run `%s'\n",
   3746                 statement);
   3747     return qs;
   3748   }
   3749   if (ctx.error)
   3750   {
   3751     GNUNET_break (0);
   3752     return GNUNET_DB_STATUS_HARD_ERROR;
   3753   }
   3754   return qs;
   3755 }
   3756 
   3757 
   3758 #undef XPREPARE
   3759 
   3760 /* end of lookup_records_by_table.c */