Mercurial > hg > orthanc-databases
annotate Framework/PostgreSQL/PostgreSQLStatement.cpp @ 234:d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 08 Apr 2021 10:50:01 +0200 |
parents | ab96698c73a3 |
children | f2b32d31fc99 |
rev | line source |
---|---|
0 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
193
3236894320d6
upgrade to year 2021
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
186
diff
changeset
|
5 * Copyright (C) 2017-2021 Osimis S.A., Belgium |
0 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU Affero General Public License | |
9 * as published by the Free Software Foundation, either version 3 of | |
10 * the License, or (at your option) any later version. | |
11 * | |
12 * This program is distributed in the hope that it will be useful, but | |
13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Affero General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Affero General Public License | |
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 **/ | |
20 | |
21 | |
107
5765cc5fd268
reverted fix for OS X that breaks other targets
Sebastien Jodogne <s.jodogne@orthanc-labs.com>
parents:
105
diff
changeset
|
22 #include "PostgreSQLIncludes.h" // Must be the first |
105 | 23 #include "PostgreSQLStatement.h" |
0 | 24 |
25 #include "../Common/BinaryStringValue.h" | |
26 #include "../Common/FileValue.h" | |
27 #include "../Common/Integer64Value.h" | |
28 #include "../Common/NullValue.h" | |
29 #include "../Common/ResultBase.h" | |
30 #include "../Common/Utf8StringValue.h" | |
31 #include "PostgreSQLResult.h" | |
32 | |
157
275e14f57f1e
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
152
diff
changeset
|
33 #include <Compatibility.h> // For std::unique_ptr<> |
152 | 34 #include <Logging.h> |
35 #include <OrthancException.h> | |
36 #include <Toolbox.h> | |
37 #include <Endianness.h> | |
0 | 38 |
39 #include <cassert> | |
40 | |
41 | |
42 namespace OrthancDatabases | |
43 { | |
44 class PostgreSQLStatement::Inputs : public boost::noncopyable | |
45 { | |
46 private: | |
47 std::vector<char*> values_; | |
48 std::vector<int> sizes_; | |
49 | |
50 static char* Allocate(const void* source, int size) | |
51 { | |
52 if (size == 0) | |
53 { | |
54 return NULL; | |
55 } | |
56 else | |
57 { | |
58 char* ptr = reinterpret_cast<char*>(malloc(size)); | |
59 | |
60 if (source != NULL) | |
61 { | |
62 memcpy(ptr, source, size); | |
63 } | |
64 | |
65 return ptr; | |
66 } | |
67 } | |
68 | |
69 void Resize(size_t size) | |
70 { | |
71 // Shrinking of the vector | |
72 for (size_t i = size; i < values_.size(); i++) | |
73 { | |
74 if (values_[i] != NULL) | |
75 free(values_[i]); | |
76 } | |
77 | |
78 values_.resize(size, NULL); | |
79 sizes_.resize(size, 0); | |
80 } | |
81 | |
82 void EnlargeForIndex(size_t index) | |
83 { | |
84 if (index >= values_.size()) | |
85 { | |
86 // The vector is too small | |
87 Resize(index + 1); | |
88 } | |
89 } | |
90 | |
91 public: | |
92 Inputs() | |
93 { | |
94 } | |
95 | |
96 ~Inputs() | |
97 { | |
98 Resize(0); | |
99 } | |
100 | |
101 void SetItem(size_t pos, const void* source, int size) | |
102 { | |
103 EnlargeForIndex(pos); | |
104 | |
105 if (sizes_[pos] == size) | |
106 { | |
107 if (source && size != 0) | |
108 { | |
109 memcpy(values_[pos], source, size); | |
110 } | |
111 } | |
112 else | |
113 { | |
114 if (values_[pos] != NULL) | |
115 { | |
116 free(values_[pos]); | |
117 } | |
118 | |
119 values_[pos] = Allocate(source, size); | |
120 sizes_[pos] = size; | |
121 } | |
122 } | |
123 | |
124 void SetItem(size_t pos, int size) | |
125 { | |
126 SetItem(pos, NULL, size); | |
127 } | |
128 | |
129 void* GetItem(size_t pos) const | |
130 { | |
131 if (pos >= values_.size()) | |
132 { | |
133 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
134 } | |
135 | |
136 return values_[pos]; | |
137 } | |
138 | |
139 const std::vector<char*>& GetValues() const | |
140 { | |
141 return values_; | |
142 } | |
143 | |
144 const std::vector<int>& GetSizes() const | |
145 { | |
146 return sizes_; | |
147 } | |
148 }; | |
149 | |
150 | |
151 void PostgreSQLStatement::Prepare() | |
152 { | |
153 if (id_.size() > 0) | |
154 { | |
155 // Already prepared | |
156 return; | |
157 } | |
158 | |
159 for (size_t i = 0; i < oids_.size(); i++) | |
160 { | |
161 if (oids_[i] == 0) | |
162 { | |
163 // The type of an input parameter was not set | |
164 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
165 } | |
166 } | |
167 | |
168 id_ = Orthanc::Toolbox::GenerateUuid(); | |
169 | |
170 const unsigned int* tmp = oids_.size() ? &oids_[0] : NULL; | |
171 | |
172 PGresult* result = PQprepare(reinterpret_cast<PGconn*>(database_.pg_), | |
173 id_.c_str(), sql_.c_str(), oids_.size(), tmp); | |
174 | |
175 if (result == NULL) | |
176 { | |
177 id_.clear(); | |
178 database_.ThrowException(true); | |
179 } | |
180 | |
181 bool ok = (PQresultStatus(result) == PGRES_COMMAND_OK); | |
182 if (ok) | |
183 { | |
184 PQclear(result); | |
185 } | |
186 else | |
187 { | |
188 std::string message = PQresultErrorMessage(result); | |
189 PQclear(result); | |
190 id_.clear(); | |
191 LOG(ERROR) << "PostgreSQL error: " << message; | |
192 database_.ThrowException(false); | |
193 } | |
194 } | |
195 | |
196 | |
197 void PostgreSQLStatement::Unprepare() | |
198 { | |
199 if (id_.size() > 0) | |
200 { | |
201 // "Although there is no libpq function for deleting a | |
202 // prepared statement, the SQL DEALLOCATE statement can be | |
203 // used for that purpose." | |
130
2d2b268799a2
Explicit deallocation of prepared statements
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
107
diff
changeset
|
204 database_.Execute("DEALLOCATE \"" + id_ + "\""); |
0 | 205 } |
206 | |
207 id_.clear(); | |
208 } | |
209 | |
210 | |
211 void PostgreSQLStatement::DeclareInputInternal(unsigned int param, | |
212 unsigned int /*Oid*/ type) | |
213 { | |
214 Unprepare(); | |
215 | |
216 if (oids_.size() <= param) | |
217 { | |
218 oids_.resize(param + 1, 0); | |
219 binary_.resize(param + 1); | |
220 } | |
221 | |
222 oids_[param] = type; | |
223 binary_[param] = (type == TEXTOID || type == BYTEAOID || type == OIDOID) ? 0 : 1; | |
224 } | |
225 | |
226 | |
227 void PostgreSQLStatement::DeclareInputInteger(unsigned int param) | |
228 { | |
229 DeclareInputInternal(param, INT4OID); | |
230 } | |
231 | |
232 | |
233 void PostgreSQLStatement::DeclareInputInteger64(unsigned int param) | |
234 { | |
235 DeclareInputInternal(param, INT8OID); | |
236 } | |
237 | |
238 | |
239 void PostgreSQLStatement::DeclareInputString(unsigned int param) | |
240 { | |
241 DeclareInputInternal(param, TEXTOID); | |
242 } | |
243 | |
244 | |
245 void PostgreSQLStatement::DeclareInputBinary(unsigned int param) | |
246 { | |
247 DeclareInputInternal(param, BYTEAOID); | |
248 } | |
249 | |
250 | |
251 void PostgreSQLStatement::DeclareInputLargeObject(unsigned int param) | |
252 { | |
253 DeclareInputInternal(param, OIDOID); | |
254 } | |
255 | |
256 | |
257 void* /* PGresult* */ PostgreSQLStatement::Execute() | |
258 { | |
259 Prepare(); | |
260 | |
261 PGresult* result; | |
262 | |
263 if (oids_.size() == 0) | |
264 { | |
265 // No parameter | |
266 result = PQexecPrepared(reinterpret_cast<PGconn*>(database_.pg_), | |
267 id_.c_str(), 0, NULL, NULL, NULL, 1); | |
268 } | |
269 else | |
270 { | |
271 // At least 1 parameter | |
272 result = PQexecPrepared(reinterpret_cast<PGconn*>(database_.pg_), | |
273 id_.c_str(), | |
274 oids_.size(), | |
275 &inputs_->GetValues()[0], | |
276 &inputs_->GetSizes()[0], | |
277 &binary_[0], | |
278 1); | |
279 } | |
280 | |
234
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
281 if (PQtransactionStatus(reinterpret_cast<PGconn*>(database_.pg_)) == PQTRANS_INERROR) |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
282 { |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
283 if (result != NULL) |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
284 { |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
285 PQclear(result); |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
286 } |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
287 |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
288 throw Orthanc::OrthancException(Orthanc::ErrorCode_DatabaseCannotSerialize); |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
289 } |
d1b124d116c1
PostgreSQL index plugin handles retries for collisions between multiple writers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
290 else if (result == NULL) |
0 | 291 { |
292 database_.ThrowException(true); | |
293 } | |
294 | |
295 return result; | |
296 } | |
297 | |
298 | |
299 PostgreSQLStatement::PostgreSQLStatement(PostgreSQLDatabase& database, | |
214
ab96698c73a3
removed useless information about read-only in ITransaction and IPrecompiledStatement
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
193
diff
changeset
|
300 const std::string& sql) : |
0 | 301 database_(database), |
302 sql_(sql), | |
303 inputs_(new Inputs), | |
304 formatter_(Dialect_PostgreSQL) | |
305 { | |
306 LOG(TRACE) << "PostgreSQL: " << sql; | |
307 } | |
308 | |
309 | |
310 PostgreSQLStatement::PostgreSQLStatement(PostgreSQLDatabase& database, | |
311 const Query& query) : | |
312 database_(database), | |
313 inputs_(new Inputs), | |
314 formatter_(Dialect_PostgreSQL) | |
315 { | |
316 query.Format(sql_, formatter_); | |
317 LOG(TRACE) << "PostgreSQL: " << sql_; | |
318 | |
319 for (size_t i = 0; i < formatter_.GetParametersCount(); i++) | |
320 { | |
321 switch (formatter_.GetParameterType(i)) | |
322 { | |
323 case ValueType_Integer64: | |
324 DeclareInputInteger64(i); | |
325 break; | |
326 | |
327 case ValueType_Utf8String: | |
328 DeclareInputString(i); | |
329 break; | |
330 | |
331 case ValueType_BinaryString: | |
332 DeclareInputBinary(i); | |
333 break; | |
334 | |
335 case ValueType_File: | |
336 DeclareInputLargeObject(i); | |
337 break; | |
338 | |
339 case ValueType_Null: | |
340 default: | |
341 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
342 } | |
343 } | |
344 } | |
345 | |
346 | |
46
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
347 PostgreSQLStatement::~PostgreSQLStatement() |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
348 { |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
349 try |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
350 { |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
351 Unprepare(); |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
352 } |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
353 catch (Orthanc::OrthancException&) |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
354 { |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
355 // Ignore possible exceptions due to connection loss |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
356 } |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
357 } |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
358 |
6a574d810b98
Compatibility with MySQL 8.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
23
diff
changeset
|
359 |
0 | 360 void PostgreSQLStatement::Run() |
361 { | |
362 PGresult* result = reinterpret_cast<PGresult*>(Execute()); | |
363 assert(result != NULL); // An exception would have been thrown otherwise | |
364 | |
365 bool ok = (PQresultStatus(result) == PGRES_COMMAND_OK || | |
366 PQresultStatus(result) == PGRES_TUPLES_OK); | |
367 if (ok) | |
368 { | |
369 PQclear(result); | |
370 } | |
371 else | |
372 { | |
373 std::string error = PQresultErrorMessage(result); | |
374 PQclear(result); | |
375 LOG(ERROR) << "PostgreSQL error: " << error; | |
376 database_.ThrowException(false); | |
377 } | |
378 } | |
379 | |
380 | |
381 void PostgreSQLStatement::BindNull(unsigned int param) | |
382 { | |
383 if (param >= oids_.size()) | |
384 { | |
385 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
386 } | |
387 | |
388 inputs_->SetItem(param, 0); | |
389 } | |
390 | |
391 | |
392 void PostgreSQLStatement::BindInteger(unsigned int param, | |
393 int value) | |
394 { | |
395 if (param >= oids_.size()) | |
396 { | |
397 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
398 } | |
399 | |
400 if (oids_[param] != INT4OID) | |
401 { | |
402 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadParameterType); | |
403 } | |
404 | |
405 assert(sizeof(int32_t) == 4); | |
406 int32_t v = htobe32(static_cast<int32_t>(value)); | |
407 inputs_->SetItem(param, &v, sizeof(int32_t)); | |
408 } | |
409 | |
410 | |
411 void PostgreSQLStatement::BindInteger64(unsigned int param, | |
412 int64_t value) | |
413 { | |
414 if (param >= oids_.size()) | |
415 { | |
416 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
417 } | |
418 | |
419 if (oids_[param] != INT8OID) | |
420 { | |
421 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadParameterType); | |
422 } | |
423 | |
424 assert(sizeof(int64_t) == 8); | |
425 int64_t v = htobe64(value); | |
426 inputs_->SetItem(param, &v, sizeof(int64_t)); | |
427 } | |
428 | |
429 | |
430 void PostgreSQLStatement::BindString(unsigned int param, | |
431 const std::string& value) | |
432 { | |
433 if (param >= oids_.size()) | |
434 { | |
435 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
436 } | |
437 | |
438 if (oids_[param] != TEXTOID && oids_[param] != BYTEAOID) | |
439 { | |
440 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadParameterType); | |
441 } | |
442 | |
443 if (value.size() == 0) | |
444 { | |
445 inputs_->SetItem(param, "", 1 /* end-of-string character */); | |
446 } | |
447 else | |
448 { | |
449 inputs_->SetItem(param, value.c_str(), | |
450 value.size() + 1); // "+1" for end-of-string character | |
451 } | |
452 } | |
453 | |
454 | |
455 void PostgreSQLStatement::BindLargeObject(unsigned int param, | |
456 const PostgreSQLLargeObject& value) | |
457 { | |
458 if (param >= oids_.size()) | |
459 { | |
460 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
461 } | |
462 | |
463 if (oids_[param] != OIDOID) | |
464 { | |
465 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadParameterType); | |
466 } | |
467 | |
468 inputs_->SetItem(param, value.GetOid().c_str(), | |
469 value.GetOid().size() + 1); // "+1" for end-of-string character | |
470 } | |
471 | |
472 | |
473 class PostgreSQLStatement::ResultWrapper : public ResultBase | |
474 { | |
475 private: | |
157
275e14f57f1e
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
152
diff
changeset
|
476 std::unique_ptr<PostgreSQLResult> result_; |
0 | 477 |
478 protected: | |
479 virtual IValue* FetchField(size_t index) | |
480 { | |
481 return result_->GetValue(index); | |
482 } | |
483 | |
484 public: | |
186 | 485 explicit ResultWrapper(PostgreSQLStatement& statement) : |
0 | 486 result_(new PostgreSQLResult(statement)) |
487 { | |
488 SetFieldsCount(result_->GetColumnsCount()); | |
489 FetchFields(); | |
490 } | |
491 | |
492 virtual void Next() | |
493 { | |
494 result_->Next(); | |
495 FetchFields(); | |
496 } | |
497 | |
498 virtual bool IsDone() const | |
499 { | |
500 return result_->IsDone(); | |
501 } | |
502 }; | |
503 | |
504 | |
23
b2ff1cd2907a
handling of implicit transactions in DatabaseManager
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
505 IResult* PostgreSQLStatement::Execute(ITransaction& transaction, |
0 | 506 const Dictionary& parameters) |
507 { | |
508 for (size_t i = 0; i < formatter_.GetParametersCount(); i++) | |
509 { | |
510 const std::string& name = formatter_.GetParameterName(i); | |
511 | |
512 switch (formatter_.GetParameterType(i)) | |
513 { | |
514 case ValueType_Integer64: | |
515 BindInteger64(i, dynamic_cast<const Integer64Value&>(parameters.GetValue(name)).GetValue()); | |
516 break; | |
517 | |
518 case ValueType_Null: | |
519 BindNull(i); | |
520 break; | |
521 | |
522 case ValueType_Utf8String: | |
523 BindString(i, dynamic_cast<const Utf8StringValue&> | |
524 (parameters.GetValue(name)).GetContent()); | |
525 break; | |
526 | |
527 case ValueType_BinaryString: | |
528 BindString(i, dynamic_cast<const BinaryStringValue&> | |
529 (parameters.GetValue(name)).GetContent()); | |
530 break; | |
531 | |
532 case ValueType_File: | |
533 { | |
534 const FileValue& blob = | |
535 dynamic_cast<const FileValue&>(parameters.GetValue(name)); | |
536 | |
537 PostgreSQLLargeObject largeObject(database_, blob.GetContent()); | |
538 BindLargeObject(i, largeObject); | |
539 break; | |
540 } | |
541 | |
542 default: | |
543 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
544 } | |
545 } | |
546 | |
547 return new ResultWrapper(*this); | |
548 } | |
549 | |
550 | |
23
b2ff1cd2907a
handling of implicit transactions in DatabaseManager
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
551 void PostgreSQLStatement::ExecuteWithoutResult(ITransaction& transaction, |
0 | 552 const Dictionary& parameters) |
553 { | |
157
275e14f57f1e
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
152
diff
changeset
|
554 std::unique_ptr<IResult> dummy(Execute(transaction, parameters)); |
0 | 555 } |
556 } |