src/pq/pq_eval.c

   1 /*
   2   This file is part of GNUnet
   3   Copyright (C) 2017 GNUnet e.V.
   4
   5   GNUnet is free software; you can redistribute it and/or modify it under the
   6   terms of the GNU General Public License as published by the Free Software
   7   Foundation; either version 3, or (at your option) any later version.
   8
   9   GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY
  10   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  11   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  12
  13   You should have received a copy of the GNU General Public License along with
  14   GNUnet; see the file COPYING.  If not, If not, see <http://www.gnu.org/licenses/>
  15 */
  16 /**
  17  * @file pq/pq_eval.c
  18  * @brief functions to execute SQL statements with arguments and/or results (PostGres)
  19  * @author Christian Grothoff
  20  */
  21 #include "platform.h"
  22 #include "gnunet_util_lib.h"
  23 #include "gnunet_pq_lib.h"
  24
  25
  26 /**
  27  * Error code returned by Postgres for deadlock.
  28  */
  29 #define PQ_DIAG_SQLSTATE_DEADLOCK "40P01"
  30
  31 /**
  32  * Error code returned by Postgres for uniqueness violation.
  33  */
  34 #define PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION "23505"
  35
  36 /**
  37  * Error code returned by Postgres on serialization failure.
  38  */
  39 #define PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE "40001"
  40
  41
  42 /**
  43  * Check the @a result's error code to see what happened.
  44  * Also logs errors.
  45  *
  46  * @param connection connection to execute the statement in
  47  * @param statement_name name of the statement that created @a result
  48  * @param result result to check
  49  * @return status code from the result, mapping PQ status
  50  *         codes to `enum GNUNET_PQ_QueryStatus`.  Never
  51  *         returns positive values as this function does
  52  *         not look at the result set.
  53  * @deprecated (low level, let's see if we can do with just the high-level functions)
  54  */
  55 enum GNUNET_PQ_QueryStatus
  56 GNUNET_PQ_eval_result (PGconn *connection,
  57                        const char *statement_name,
  58                        PGresult *result)
  59 {
  60   ExecStatusType est;
  61
  62   est = PQresultStatus (result);
  63   if ( (PGRES_COMMAND_OK != est) &&
  64        (PGRES_TUPLES_OK != est) )
  65   {
  66     const char *sqlstate;
  67
  68     sqlstate = PQresultErrorField (result,
  69                                    PG_DIAG_SQLSTATE);
  70     if (NULL == sqlstate)
  71     {
  72       /* very unexpected... */
  73       GNUNET_break (0);
  74       return GNUNET_PQ_STATUS_HARD_ERROR;
  75     }
  76     if ( (0 == strcmp (sqlstate,
  77                        PQ_DIAG_SQLSTATE_DEADLOCK)) ||
  78          (0 == strcmp (sqlstate,
  79                        PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)) )
  80     {
  81       /* These two can be retried and have a fair chance of working
  82          the next time */
  83       GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
  84                        "pq",
  85                        "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
  86                        statement_name,
  87                        PQresultErrorField (result,
  88                                            PG_DIAG_MESSAGE_PRIMARY),
  89                        PQresultErrorField (result,
  90                                            PG_DIAG_MESSAGE_DETAIL),
  91                        PQresultErrorMessage (result),
  92                        PQresStatus (PQresultStatus (result)),
  93                        PQerrorMessage (connection));
  94       return GNUNET_PQ_STATUS_SOFT_ERROR;
  95     }
  96     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
  97                      "pq",
  98                      "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
  99                      statement_name,
 100                      PQresultErrorField (result,
 101                                          PG_DIAG_MESSAGE_PRIMARY),
 102                      PQresultErrorField (result,
 103                                          PG_DIAG_MESSAGE_DETAIL),
 104                      PQresultErrorMessage (result),
 105                      PQresStatus (PQresultStatus (result)),
 106                      PQerrorMessage (connection));
 107     return GNUNET_PQ_STATUS_HARD_ERROR;
 108   }
 109   return GNUNET_PQ_STATUS_SUCCESS_NO_RESULTS;
 110 }
 111
 112
 113 /**
 114  * Execute a named prepared @a statement that is NOT a SELECT
 115  * statement in @a connnection using the given @a params.  Returns the
 116  * resulting session state.
 117  *
 118  * @param connection connection to execute the statement in
 119  * @param statement_name name of the statement
 120  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 121  * @return status code from the result, mapping PQ status
 122  *         codes to `enum GNUNET_PQ_QueryStatus`.  Never
 123  *         returns positive values as this function does
 124  *         not look at the result set.
 125  */
 126 enum GNUNET_PQ_QueryStatus
 127 GNUNET_PQ_eval_prepared_non_select (PGconn *connection,
 128                                     const char *statement_name,
 129                                     const struct GNUNET_PQ_QueryParam *params)
 130 {
 131   PGresult *result;
 132   enum GNUNET_PQ_QueryStatus qs;
 133
 134   result = GNUNET_PQ_exec_prepared (connection,
 135                                     statement_name,
 136                                     params);
 137   qs = GNUNET_PQ_eval_result (connection,
 138                               statement_name,
 139                               result);
 140   PQclear (result);
 141   return qs;
 142 }
 143
 144
 145 /**
 146  * Execute a named prepared @a statement that is a SELECT statement
 147  * which may return multiple results in @a connection using the given
 148  * @a params.  Call @a rh with the results.  Returns the query
 149  * status including the number of results given to @a rh (possibly zero).
 150  * @a rh will not have been called if the return value is negative.
 151  *
 152  * @param connection connection to execute the statement in
 153  * @param statement_name name of the statement
 154  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 155  * @param rh function to call with the result set, NULL to ignore
 156  * @param rh_cls closure to pass to @a rh
 157  * @return status code from the result, mapping PQ status
 158  *         codes to `enum GNUNET_PQ_QueryStatus`.
 159  */
 160 enum GNUNET_PQ_QueryStatus
 161 GNUNET_PQ_eval_prepared_multi_select (PGconn *connection,
 162                                       const char *statement_name,
 163                                       const struct GNUNET_PQ_QueryParam *params,
 164                                       GNUNET_PQ_PostgresResultHandler rh,
 165                                       void *rh_cls)
 166 {
 167   PGresult *result;
 168   enum GNUNET_PQ_QueryStatus qs;
 169   unsigned int ret;
 170
 171   result = GNUNET_PQ_exec_prepared (connection,
 172                                     statement_name,
 173                                     params);
 174   qs = GNUNET_PQ_eval_result (connection,
 175                               statement_name,
 176                               result);
 177   if (qs < 0)
 178   {
 179     PQclear (result);
 180     return qs;
 181   }
 182   ret = PQntuples (result);
 183   if (NULL != rh)
 184     rh (rh_cls,
 185         result,
 186         ret);
 187   PQclear (result);
 188   return ret;
 189 }
 190
 191
 192 /**
 193  * Execute a named prepared @a statement that is a SELECT statement
 194  * which must return a single result in @a connection using the given
 195  * @a params.  Stores the result (if any) in @a rs, which the caller
 196  * must then clean up using #GNUNET_PQ_cleanup_result() if the return
 197  * value was #GNUNET_PQ_STATUS_SUCCESS_ONE_RESULT.  Returns the
 198  * resulting session status.
 199  *
 200  * @param connection connection to execute the statement in
 201  * @param statement_name name of the statement
 202  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 203  * @param[in,out] rs result specification to use for storing the result of the query
 204  * @return status code from the result, mapping PQ status
 205  *         codes to `enum GNUNET_PQ_QueryStatus`.
 206  */
 207 enum GNUNET_PQ_QueryStatus
 208 GNUNET_PQ_eval_prepared_singleton_select (PGconn *connection,
 209                                           const char *statement_name,
 210                                           const struct GNUNET_PQ_QueryParam *params,
 211                                           struct GNUNET_PQ_ResultSpec *rs)
 212 {
 213   PGresult *result;
 214   enum GNUNET_PQ_QueryStatus qs;
 215
 216   result = GNUNET_PQ_exec_prepared (connection,
 217                                     statement_name,
 218                                     params);
 219   qs = GNUNET_PQ_eval_result (connection,
 220                               statement_name,
 221                               result);
 222   if (qs < 0)
 223   {
 224     PQclear (result);
 225     return qs;
 226   }
 227   if (0 == PQntuples (result))
 228   {
 229     PQclear (result);
 230     return GNUNET_PQ_STATUS_SUCCESS_NO_RESULTS;
 231   }
 232   if (1 != PQntuples (result))
 233   {
 234     /* more than one result, but there must be at most one */
 235     GNUNET_break (0);
 236     PQclear (result);
 237     return GNUNET_PQ_STATUS_HARD_ERROR;
 238   }
 239   if (GNUNET_OK !=
 240       GNUNET_PQ_extract_result (result,
 241                                 rs,
 242                                 0))
 243   {
 244     PQclear (result);
 245     return GNUNET_PQ_STATUS_HARD_ERROR;
 246   }
 247   PQclear (result);
 248   return GNUNET_PQ_STATUS_SUCCESS_ONE_RESULT;
 249 }
 250
 251
 252 /* end of pq/pq_eval.c */