summaryrefslogtreecommitdiff
path: root/src/pq/pq_eval.c
diff options
context:
space:
mode:
authorng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
committerng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
commitd41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch)
tree9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/pq/pq_eval.c
parenta0fce305c565c0937d917a92712f15e9c5736260 (diff)
downloadgnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz
gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip
uncrustify as demanded.
Diffstat (limited to 'src/pq/pq_eval.c')
-rw-r--r--src/pq/pq_eval.c294
1 files changed, 147 insertions, 147 deletions
diff --git a/src/pq/pq_eval.c b/src/pq/pq_eval.c
index 2beb3475b..0df71e672 100644
--- a/src/pq/pq_eval.c
+++ b/src/pq/pq_eval.c
@@ -1,22 +1,22 @@
1/* 1/*
2 This file is part of GNUnet 2 This file is part of GNUnet
3 Copyright (C) 2017 GNUnet e.V. 3 Copyright (C) 2017 GNUnet e.V.
4 4
5 GNUnet is free software: you can redistribute it and/or modify it 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 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, 7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version. 8 or (at your option) any later version.
9 9
10 GNUnet is distributed in the hope that it will be useful, but 10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 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/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file pq/pq_eval.c 21 * @file pq/pq_eval.c
22 * @brief functions to execute SQL statements with arguments and/or results (PostGres) 22 * @brief functions to execute SQL statements with arguments and/or results (PostGres)
@@ -57,76 +57,76 @@
57 * @deprecated (low level, let's see if we can do with just the high-level functions) 57 * @deprecated (low level, let's see if we can do with just the high-level functions)
58 */ 58 */
59enum GNUNET_DB_QueryStatus 59enum GNUNET_DB_QueryStatus
60GNUNET_PQ_eval_result (PGconn *connection, 60GNUNET_PQ_eval_result(PGconn *connection,
61 const char *statement_name, 61 const char *statement_name,
62 PGresult *result) 62 PGresult *result)
63{ 63{
64 ExecStatusType est; 64 ExecStatusType est;
65 65
66 est = PQresultStatus (result); 66 est = PQresultStatus(result);
67 if ( (PGRES_COMMAND_OK != est) && 67 if ((PGRES_COMMAND_OK != est) &&
68 (PGRES_TUPLES_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 { 69 {
76 /* very unexpected... */ 70 const char *sqlstate;
77 GNUNET_break (0); 71
78 return GNUNET_DB_STATUS_HARD_ERROR; 72 sqlstate = PQresultErrorField(result,
79 } 73 PG_DIAG_SQLSTATE);
80 if ( (0 == strcmp (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)) || 81 PQ_DIAG_SQLSTATE_DEADLOCK)) ||
82 (0 == strcmp (sqlstate, 82 (0 == strcmp(sqlstate,
83 PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)) ) 83 PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)))
84 { 84 {
85 /* These two can be retried and have a fair chance of working 85 /* These two can be retried and have a fair chance of working
86 the next time */ 86 the next time */
87 GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, 87 GNUNET_log_from(GNUNET_ERROR_TYPE_INFO,
88 "pq", 88 "pq",
89 "Query `%s' failed with result: %s/%s/%s/%s/%s\n", 89 "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
90 statement_name, 90 statement_name,
91 PQresultErrorField (result, 91 PQresultErrorField(result,
92 PG_DIAG_MESSAGE_PRIMARY), 92 PG_DIAG_MESSAGE_PRIMARY),
93 PQresultErrorField (result, 93 PQresultErrorField(result,
94 PG_DIAG_MESSAGE_DETAIL), 94 PG_DIAG_MESSAGE_DETAIL),
95 PQresultErrorMessage (result), 95 PQresultErrorMessage(result),
96 PQresStatus (PQresultStatus (result)), 96 PQresStatus(PQresultStatus(result)),
97 PQerrorMessage (connection)); 97 PQerrorMessage(connection));
98 return GNUNET_DB_STATUS_SOFT_ERROR; 98 return GNUNET_DB_STATUS_SOFT_ERROR;
99 } 99 }
100 if (0 == strcmp (sqlstate, 100 if (0 == strcmp(sqlstate,
101 PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION)) 101 PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION))
102 { 102 {
103 /* Likely no need to retry, INSERT of "same" data. */ 103 /* Likely no need to retry, INSERT of "same" data. */
104 GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 104 GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
105 "pq", 105 "pq",
106 "Query `%s' failed with unique violation: %s/%s/%s/%s/%s\n", 106 "Query `%s' failed with unique violation: %s/%s/%s/%s/%s\n",
107 statement_name, 107 statement_name,
108 PQresultErrorField (result, 108 PQresultErrorField(result,
109 PG_DIAG_MESSAGE_PRIMARY), 109 PG_DIAG_MESSAGE_PRIMARY),
110 PQresultErrorField (result, 110 PQresultErrorField(result,
111 PG_DIAG_MESSAGE_DETAIL), 111 PG_DIAG_MESSAGE_DETAIL),
112 PQresultErrorMessage (result), 112 PQresultErrorMessage(result),
113 PQresStatus (PQresultStatus (result)), 113 PQresStatus(PQresultStatus(result)),
114 PQerrorMessage (connection)); 114 PQerrorMessage(connection));
115 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS; 115 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
116 } 116 }
117 GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, 117 GNUNET_log_from(GNUNET_ERROR_TYPE_ERROR,
118 "pq", 118 "pq",
119 "Query `%s' failed with result: %s/%s/%s/%s/%s\n", 119 "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
120 statement_name, 120 statement_name,
121 PQresultErrorField (result, 121 PQresultErrorField(result,
122 PG_DIAG_MESSAGE_PRIMARY), 122 PG_DIAG_MESSAGE_PRIMARY),
123 PQresultErrorField (result, 123 PQresultErrorField(result,
124 PG_DIAG_MESSAGE_DETAIL), 124 PG_DIAG_MESSAGE_DETAIL),
125 PQresultErrorMessage (result), 125 PQresultErrorMessage(result),
126 PQresStatus (PQresultStatus (result)), 126 PQresStatus(PQresultStatus(result)),
127 PQerrorMessage (connection)); 127 PQerrorMessage(connection));
128 return GNUNET_DB_STATUS_HARD_ERROR; 128 return GNUNET_DB_STATUS_HARD_ERROR;
129 } 129 }
130 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS; 130 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
131} 131}
132 132
@@ -148,29 +148,29 @@ GNUNET_PQ_eval_result (PGconn *connection,
148 * zero; if INSERT was successful, we return one. 148 * zero; if INSERT was successful, we return one.
149 */ 149 */
150enum GNUNET_DB_QueryStatus 150enum GNUNET_DB_QueryStatus
151GNUNET_PQ_eval_prepared_non_select (PGconn *connection, 151GNUNET_PQ_eval_prepared_non_select(PGconn *connection,
152 const char *statement_name, 152 const char *statement_name,
153 const struct GNUNET_PQ_QueryParam *params) 153 const struct GNUNET_PQ_QueryParam *params)
154{ 154{
155 PGresult *result; 155 PGresult *result;
156 enum GNUNET_DB_QueryStatus qs; 156 enum GNUNET_DB_QueryStatus qs;
157 157
158 result = GNUNET_PQ_exec_prepared (connection, 158 result = GNUNET_PQ_exec_prepared(connection,
159 statement_name, 159 statement_name,
160 params); 160 params);
161 qs = GNUNET_PQ_eval_result (connection, 161 qs = GNUNET_PQ_eval_result(connection,
162 statement_name, 162 statement_name,
163 result); 163 result);
164 if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs) 164 if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs)
165 { 165 {
166 const char *tuples; 166 const char *tuples;
167 167
168 /* What an awful API, this function really does return a string */ 168 /* What an awful API, this function really does return a string */
169 tuples = PQcmdTuples (result); 169 tuples = PQcmdTuples(result);
170 if (NULL != tuples) 170 if (NULL != tuples)
171 qs = strtol (tuples, NULL, 10); 171 qs = strtol(tuples, NULL, 10);
172 } 172 }
173 PQclear (result); 173 PQclear(result);
174 return qs; 174 return qs;
175} 175}
176 176
@@ -191,33 +191,33 @@ GNUNET_PQ_eval_prepared_non_select (PGconn *connection,
191 * codes to `enum GNUNET_DB_QueryStatus`. 191 * codes to `enum GNUNET_DB_QueryStatus`.
192 */ 192 */
193enum GNUNET_DB_QueryStatus 193enum GNUNET_DB_QueryStatus
194GNUNET_PQ_eval_prepared_multi_select (PGconn *connection, 194GNUNET_PQ_eval_prepared_multi_select(PGconn *connection,
195 const char *statement_name, 195 const char *statement_name,
196 const struct GNUNET_PQ_QueryParam *params, 196 const struct GNUNET_PQ_QueryParam *params,
197 GNUNET_PQ_PostgresResultHandler rh, 197 GNUNET_PQ_PostgresResultHandler rh,
198 void *rh_cls) 198 void *rh_cls)
199{ 199{
200 PGresult *result; 200 PGresult *result;
201 enum GNUNET_DB_QueryStatus qs; 201 enum GNUNET_DB_QueryStatus qs;
202 unsigned int ret; 202 unsigned int ret;
203 203
204 result = GNUNET_PQ_exec_prepared (connection, 204 result = GNUNET_PQ_exec_prepared(connection,
205 statement_name, 205 statement_name,
206 params); 206 params);
207 qs = GNUNET_PQ_eval_result (connection, 207 qs = GNUNET_PQ_eval_result(connection,
208 statement_name, 208 statement_name,
209 result); 209 result);
210 if (qs < 0) 210 if (qs < 0)
211 { 211 {
212 PQclear (result); 212 PQclear(result);
213 return qs; 213 return qs;
214 } 214 }
215 ret = PQntuples (result); 215 ret = PQntuples(result);
216 if (NULL != rh) 216 if (NULL != rh)
217 rh (rh_cls, 217 rh(rh_cls,
218 result, 218 result,
219 ret); 219 ret);
220 PQclear (result); 220 PQclear(result);
221 return ret; 221 return ret;
222} 222}
223 223
@@ -238,46 +238,46 @@ GNUNET_PQ_eval_prepared_multi_select (PGconn *connection,
238 * codes to `enum GNUNET_DB_QueryStatus`. 238 * codes to `enum GNUNET_DB_QueryStatus`.
239 */ 239 */
240enum GNUNET_DB_QueryStatus 240enum GNUNET_DB_QueryStatus
241GNUNET_PQ_eval_prepared_singleton_select (PGconn *connection, 241GNUNET_PQ_eval_prepared_singleton_select(PGconn *connection,
242 const char *statement_name, 242 const char *statement_name,
243 const struct GNUNET_PQ_QueryParam *params, 243 const struct GNUNET_PQ_QueryParam *params,
244 struct GNUNET_PQ_ResultSpec *rs) 244 struct GNUNET_PQ_ResultSpec *rs)
245{ 245{
246 PGresult *result; 246 PGresult *result;
247 enum GNUNET_DB_QueryStatus qs; 247 enum GNUNET_DB_QueryStatus qs;
248 248
249 result = GNUNET_PQ_exec_prepared (connection, 249 result = GNUNET_PQ_exec_prepared(connection,
250 statement_name, 250 statement_name,
251 params); 251 params);
252 qs = GNUNET_PQ_eval_result (connection, 252 qs = GNUNET_PQ_eval_result(connection,
253 statement_name, 253 statement_name,
254 result); 254 result);
255 if (qs < 0) 255 if (qs < 0)
256 { 256 {
257 PQclear (result); 257 PQclear(result);
258 return qs; 258 return qs;
259 } 259 }
260 if (0 == PQntuples (result)) 260 if (0 == PQntuples(result))
261 { 261 {
262 PQclear (result); 262 PQclear(result);
263 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS; 263 return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
264 } 264 }
265 if (1 != PQntuples (result)) 265 if (1 != PQntuples(result))
266 { 266 {
267 /* more than one result, but there must be at most one */ 267 /* more than one result, but there must be at most one */
268 GNUNET_break (0); 268 GNUNET_break(0);
269 PQclear (result); 269 PQclear(result);
270 return GNUNET_DB_STATUS_HARD_ERROR; 270 return GNUNET_DB_STATUS_HARD_ERROR;
271 } 271 }
272 if (GNUNET_OK != 272 if (GNUNET_OK !=
273 GNUNET_PQ_extract_result (result, 273 GNUNET_PQ_extract_result(result,
274 rs, 274 rs,
275 0)) 275 0))
276 { 276 {
277 PQclear (result); 277 PQclear(result);
278 return GNUNET_DB_STATUS_HARD_ERROR; 278 return GNUNET_DB_STATUS_HARD_ERROR;
279 } 279 }
280 PQclear (result); 280 PQclear(result);
281 return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT; 281 return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
282} 282}
283 283