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
   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 pq/pq_eval.c
  22  * @brief functions to execute SQL statements with arguments and/or results (PostGres)
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_pq_lib.h"
  28
  29
  30 /**
  31  * Error code returned by Postgres for deadlock.
  32  */
  33 #define PQ_DIAG_SQLSTATE_DEADLOCK "40P01"
  34
  35 /**
  36  * Error code returned by Postgres for uniqueness violation.
  37  */
  38 #define PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION "23505"
  39
  40 /**
  41  * Error code returned by Postgres on serialization failure.
  42  */
  43 #define PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE "40001"
  44
  45
  46 /**
  47  * Check the @a result's error code to see what happened.
  48  * Also logs errors.
  49  *
  50  * @param connection connection to execute the statement in
  51  * @param statement_name name of the statement that created @a result
  52  * @param result result to check
  53  * @return status code from the result, mapping PQ status
  54  *         codes to `enum GNUNET_DB_QueryStatus`.  Never
  55  *         returns positive values as this function does
  56  *         not look at the result set.
  57  * @deprecated (low level, let's see if we can do with just the high-level functions)
  58  */
  59 enum GNUNET_DB_QueryStatus
  60 GNUNET_PQ_eval_result(PGconn *connection,
  61                       const char *statement_name,
  62                       PGresult *result)
  63 {
  64   ExecStatusType est;
  65
  66   est = PQresultStatus(result);
  67   if ((PGRES_COMMAND_OK != est) &&
  68       (PGRES_TUPLES_OK != est))
  69     {
  70       const char *sqlstate;
  71
  72       sqlstate = PQresultErrorField(result,
  73                                     PG_DIAG_SQLSTATE);
  74       if (NULL == sqlstate)
  75         {
  76           /* very unexpected... */
  77           GNUNET_break(0);
  78           return GNUNET_DB_STATUS_HARD_ERROR;
  79         }
  80       if ((0 == strcmp(sqlstate,
  81                        PQ_DIAG_SQLSTATE_DEADLOCK)) ||
  82           (0 == strcmp(sqlstate,
  83                        PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)))
  84         {
  85           /* These two can be retried and have a fair chance of working
  86              the next time */
  87           GNUNET_log_from(GNUNET_ERROR_TYPE_INFO,
  88                           "pq",
  89                           "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
  90                           statement_name,
  91                           PQresultErrorField(result,
  92                                              PG_DIAG_MESSAGE_PRIMARY),
  93                           PQresultErrorField(result,
  94                                              PG_DIAG_MESSAGE_DETAIL),
  95                           PQresultErrorMessage(result),
  96                           PQresStatus(PQresultStatus(result)),
  97                           PQerrorMessage(connection));
  98           return GNUNET_DB_STATUS_SOFT_ERROR;
  99         }
 100       if (0 == strcmp(sqlstate,
 101                       PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION))
 102         {
 103           /* Likely no need to retry, INSERT of "same" data. */
 104           GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
 105                           "pq",
 106                           "Query `%s' failed with unique violation: %s/%s/%s/%s/%s\n",
 107                           statement_name,
 108                           PQresultErrorField(result,
 109                                              PG_DIAG_MESSAGE_PRIMARY),
 110                           PQresultErrorField(result,
 111                                              PG_DIAG_MESSAGE_DETAIL),
 112                           PQresultErrorMessage(result),
 113                           PQresStatus(PQresultStatus(result)),
 114                           PQerrorMessage(connection));
 115           return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
 116         }
 117       GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR,
 118                       "pq",
 119                       "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
 120                       statement_name,
 121                       PQresultErrorField(result,
 122                                          PG_DIAG_MESSAGE_PRIMARY),
 123                       PQresultErrorField(result,
 124                                          PG_DIAG_MESSAGE_DETAIL),
 125                       PQresultErrorMessage(result),
 126                       PQresStatus(PQresultStatus(result)),
 127                       PQerrorMessage(connection));
 128       return GNUNET_DB_STATUS_HARD_ERROR;
 129     }
 130   return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
 131 }
 132
 133
 134 /**
 135  * Execute a named prepared @a statement that is NOT a SELECT
 136  * statement in @a connnection using the given @a params.  Returns the
 137  * resulting session state.
 138  *
 139  * @param connection connection to execute the statement in
 140  * @param statement_name name of the statement
 141  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 142  * @return status code from the result, mapping PQ status
 143  *         codes to `enum GNUNET_DB_QueryStatus`.  If the
 144  *         statement was a DELETE or UPDATE statement, the
 145  *         number of affected rows is returned.; if the
 146  *         statment was an INSERT statement, and no row
 147  *         was added due to a UNIQUE violation, we return
 148  *         zero; if INSERT was successful, we return one.
 149  */
 150 enum GNUNET_DB_QueryStatus
 151 GNUNET_PQ_eval_prepared_non_select(PGconn *connection,
 152                                    const char *statement_name,
 153                                    const struct GNUNET_PQ_QueryParam *params)
 154 {
 155   PGresult *result;
 156   enum GNUNET_DB_QueryStatus qs;
 157
 158   result = GNUNET_PQ_exec_prepared(connection,
 159                                    statement_name,
 160                                    params);
 161   qs = GNUNET_PQ_eval_result(connection,
 162                              statement_name,
 163                              result);
 164   if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs)
 165     {
 166       const char *tuples;
 167
 168       /* What an awful API, this function really does return a string */
 169       tuples = PQcmdTuples(result);
 170       if (NULL != tuples)
 171         qs = strtol(tuples, NULL, 10);
 172     }
 173   PQclear(result);
 174   return qs;
 175 }
 176
 177
 178 /**
 179  * Execute a named prepared @a statement that is a SELECT statement
 180  * which may return multiple results in @a connection using the given
 181  * @a params.  Call @a rh with the results.  Returns the query
 182  * status including the number of results given to @a rh (possibly zero).
 183  * @a rh will not have been called if the return value is negative.
 184  *
 185  * @param connection connection to execute the statement in
 186  * @param statement_name name of the statement
 187  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 188  * @param rh function to call with the result set, NULL to ignore
 189  * @param rh_cls closure to pass to @a rh
 190  * @return status code from the result, mapping PQ status
 191  *         codes to `enum GNUNET_DB_QueryStatus`.
 192  */
 193 enum GNUNET_DB_QueryStatus
 194 GNUNET_PQ_eval_prepared_multi_select(PGconn *connection,
 195                                      const char *statement_name,
 196                                      const struct GNUNET_PQ_QueryParam *params,
 197                                      GNUNET_PQ_PostgresResultHandler rh,
 198                                      void *rh_cls)
 199 {
 200   PGresult *result;
 201   enum GNUNET_DB_QueryStatus qs;
 202   unsigned int ret;
 203
 204   result = GNUNET_PQ_exec_prepared(connection,
 205                                    statement_name,
 206                                    params);
 207   qs = GNUNET_PQ_eval_result(connection,
 208                              statement_name,
 209                              result);
 210   if (qs < 0)
 211     {
 212       PQclear(result);
 213       return qs;
 214     }
 215   ret = PQntuples(result);
 216   if (NULL != rh)
 217     rh(rh_cls,
 218        result,
 219        ret);
 220   PQclear(result);
 221   return ret;
 222 }
 223
 224
 225 /**
 226  * Execute a named prepared @a statement that is a SELECT statement
 227  * which must return a single result in @a connection using the given
 228  * @a params.  Stores the result (if any) in @a rs, which the caller
 229  * must then clean up using #GNUNET_PQ_cleanup_result() if the return
 230  * value was #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT.  Returns the
 231  * resulting session status.
 232  *
 233  * @param connection connection to execute the statement in
 234  * @param statement_name name of the statement
 235  * @param params parameters to give to the statement (#GNUNET_PQ_query_param_end-terminated)
 236  * @param[in,out] rs result specification to use for storing the result of the query
 237  * @return status code from the result, mapping PQ status
 238  *         codes to `enum GNUNET_DB_QueryStatus`.
 239  */
 240 enum GNUNET_DB_QueryStatus
 241 GNUNET_PQ_eval_prepared_singleton_select(PGconn *connection,
 242                                          const char *statement_name,
 243                                          const struct GNUNET_PQ_QueryParam *params,
 244                                          struct GNUNET_PQ_ResultSpec *rs)
 245 {
 246   PGresult *result;
 247   enum GNUNET_DB_QueryStatus qs;
 248
 249   result = GNUNET_PQ_exec_prepared(connection,
 250                                    statement_name,
 251                                    params);
 252   qs = GNUNET_PQ_eval_result(connection,
 253                              statement_name,
 254                              result);
 255   if (qs < 0)
 256     {
 257       PQclear(result);
 258       return qs;
 259     }
 260   if (0 == PQntuples(result))
 261     {
 262       PQclear(result);
 263       return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
 264     }
 265   if (1 != PQntuples(result))
 266     {
 267       /* more than one result, but there must be at most one */
 268       GNUNET_break(0);
 269       PQclear(result);
 270       return GNUNET_DB_STATUS_HARD_ERROR;
 271     }
 272   if (GNUNET_OK !=
 273       GNUNET_PQ_extract_result(result,
 274                                rs,
 275                                0))
 276     {
 277       PQclear(result);
 278       return GNUNET_DB_STATUS_HARD_ERROR;
 279     }
 280   PQclear(result);
 281   return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
 282 }
 283
 284
 285 /* end of pq/pq_eval.c */