Mercurial > hg > orthanc
comparison OrthancServer/DatabaseWrapper.cpp @ 1670:16955f8fec4d db-changes
refactoring: DatabaseWrapperBase
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 01 Oct 2015 14:03:07 +0200 |
parents | a412ad57f0f9 |
children | 2f2e2ec17bc4 |
comparison
equal
deleted
inserted
replaced
1669:a412ad57f0f9 | 1670:16955f8fec4d |
---|---|
185 } | 185 } |
186 }; | 186 }; |
187 } | 187 } |
188 | 188 |
189 | 189 |
190 | |
191 void DatabaseWrapper::SetGlobalProperty(GlobalProperty property, | |
192 const std::string& value) | |
193 { | |
194 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO GlobalProperties VALUES(?, ?)"); | |
195 s.BindInt(0, property); | |
196 s.BindString(1, value); | |
197 s.Run(); | |
198 } | |
199 | |
200 bool DatabaseWrapper::LookupGlobalProperty(std::string& target, | |
201 GlobalProperty property) | |
202 { | |
203 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
204 "SELECT value FROM GlobalProperties WHERE property=?"); | |
205 s.BindInt(0, property); | |
206 | |
207 if (!s.Step()) | |
208 { | |
209 return false; | |
210 } | |
211 else | |
212 { | |
213 target = s.ColumnString(0); | |
214 return true; | |
215 } | |
216 } | |
217 | |
218 int64_t DatabaseWrapper::CreateResource(const std::string& publicId, | |
219 ResourceType type) | |
220 { | |
221 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Resources VALUES(NULL, ?, ?, NULL)"); | |
222 s.BindInt(0, type); | |
223 s.BindString(1, publicId); | |
224 s.Run(); | |
225 return db_.GetLastInsertRowId(); | |
226 } | |
227 | |
228 bool DatabaseWrapper::LookupResource(int64_t& id, | |
229 ResourceType& type, | |
230 const std::string& publicId) | |
231 { | |
232 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
233 "SELECT internalId, resourceType FROM Resources WHERE publicId=?"); | |
234 s.BindString(0, publicId); | |
235 | |
236 if (!s.Step()) | |
237 { | |
238 return false; | |
239 } | |
240 else | |
241 { | |
242 id = s.ColumnInt(0); | |
243 type = static_cast<ResourceType>(s.ColumnInt(1)); | |
244 | |
245 // Check whether there is a single resource with this public id | |
246 assert(!s.Step()); | |
247 | |
248 return true; | |
249 } | |
250 } | |
251 | |
252 bool DatabaseWrapper::LookupParent(int64_t& parentId, | |
253 int64_t resourceId) | |
254 { | |
255 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
256 "SELECT parentId FROM Resources WHERE internalId=?"); | |
257 s.BindInt64(0, resourceId); | |
258 | |
259 if (!s.Step()) | |
260 { | |
261 throw OrthancException(ErrorCode_UnknownResource); | |
262 } | |
263 | |
264 if (s.ColumnIsNull(0)) | |
265 { | |
266 return false; | |
267 } | |
268 else | |
269 { | |
270 parentId = s.ColumnInt(0); | |
271 return true; | |
272 } | |
273 } | |
274 | |
275 std::string DatabaseWrapper::GetPublicId(int64_t resourceId) | |
276 { | |
277 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
278 "SELECT publicId FROM Resources WHERE internalId=?"); | |
279 s.BindInt64(0, resourceId); | |
280 | |
281 if (!s.Step()) | |
282 { | |
283 throw OrthancException(ErrorCode_UnknownResource); | |
284 } | |
285 | |
286 return s.ColumnString(0); | |
287 } | |
288 | |
289 | |
290 ResourceType DatabaseWrapper::GetResourceType(int64_t resourceId) | |
291 { | |
292 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
293 "SELECT resourceType FROM Resources WHERE internalId=?"); | |
294 s.BindInt64(0, resourceId); | |
295 | |
296 if (!s.Step()) | |
297 { | |
298 throw OrthancException(ErrorCode_UnknownResource); | |
299 } | |
300 | |
301 return static_cast<ResourceType>(s.ColumnInt(0)); | |
302 } | |
303 | |
304 | |
305 void DatabaseWrapper::AttachChild(int64_t parent, | |
306 int64_t child) | |
307 { | |
308 SQLite::Statement s(db_, SQLITE_FROM_HERE, "UPDATE Resources SET parentId = ? WHERE internalId = ?"); | |
309 s.BindInt64(0, parent); | |
310 s.BindInt64(1, child); | |
311 s.Run(); | |
312 } | |
313 | |
314 | 190 |
315 void DatabaseWrapper::GetChildren(std::list<std::string>& childrenPublicIds, | 191 void DatabaseWrapper::GetChildren(std::list<std::string>& childrenPublicIds, |
316 int64_t id) | 192 int64_t id) |
317 { | 193 { |
318 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE parentId=?"); | 194 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE parentId=?"); |
340 listener_->SignalRemainingAncestor(signalRemainingAncestor_->GetRemainingAncestorType(), | 216 listener_->SignalRemainingAncestor(signalRemainingAncestor_->GetRemainingAncestorType(), |
341 signalRemainingAncestor_->GetRemainingAncestorId()); | 217 signalRemainingAncestor_->GetRemainingAncestorId()); |
342 } | 218 } |
343 } | 219 } |
344 | 220 |
345 void DatabaseWrapper::SetMetadata(int64_t id, | |
346 MetadataType type, | |
347 const std::string& value) | |
348 { | |
349 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT OR REPLACE INTO Metadata VALUES(?, ?, ?)"); | |
350 s.BindInt64(0, id); | |
351 s.BindInt(1, type); | |
352 s.BindString(2, value); | |
353 s.Run(); | |
354 } | |
355 | |
356 void DatabaseWrapper::DeleteMetadata(int64_t id, | |
357 MetadataType type) | |
358 { | |
359 SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM Metadata WHERE id=? and type=?"); | |
360 s.BindInt64(0, id); | |
361 s.BindInt(1, type); | |
362 s.Run(); | |
363 } | |
364 | |
365 bool DatabaseWrapper::LookupMetadata(std::string& target, | |
366 int64_t id, | |
367 MetadataType type) | |
368 { | |
369 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
370 "SELECT value FROM Metadata WHERE id=? AND type=?"); | |
371 s.BindInt64(0, id); | |
372 s.BindInt(1, type); | |
373 | |
374 if (!s.Step()) | |
375 { | |
376 return false; | |
377 } | |
378 else | |
379 { | |
380 target = s.ColumnString(0); | |
381 return true; | |
382 } | |
383 } | |
384 | |
385 void DatabaseWrapper::ListAvailableMetadata(std::list<MetadataType>& target, | |
386 int64_t id) | |
387 { | |
388 target.clear(); | |
389 | |
390 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT type FROM Metadata WHERE id=?"); | |
391 s.BindInt64(0, id); | |
392 | |
393 while (s.Step()) | |
394 { | |
395 target.push_back(static_cast<MetadataType>(s.ColumnInt(0))); | |
396 } | |
397 } | |
398 | |
399 | |
400 void DatabaseWrapper::AddAttachment(int64_t id, | |
401 const FileInfo& attachment) | |
402 { | |
403 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO AttachedFiles VALUES(?, ?, ?, ?, ?, ?, ?, ?)"); | |
404 s.BindInt64(0, id); | |
405 s.BindInt(1, attachment.GetContentType()); | |
406 s.BindString(2, attachment.GetUuid()); | |
407 s.BindInt64(3, attachment.GetCompressedSize()); | |
408 s.BindInt64(4, attachment.GetUncompressedSize()); | |
409 s.BindInt(5, attachment.GetCompressionType()); | |
410 s.BindString(6, attachment.GetUncompressedMD5()); | |
411 s.BindString(7, attachment.GetCompressedMD5()); | |
412 s.Run(); | |
413 } | |
414 | |
415 | |
416 void DatabaseWrapper::DeleteAttachment(int64_t id, | |
417 FileContentType attachment) | |
418 { | |
419 SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM AttachedFiles WHERE id=? AND fileType=?"); | |
420 s.BindInt64(0, id); | |
421 s.BindInt(1, attachment); | |
422 s.Run(); | |
423 } | |
424 | |
425 | |
426 | |
427 void DatabaseWrapper::ListAvailableAttachments(std::list<FileContentType>& target, | |
428 int64_t id) | |
429 { | |
430 target.clear(); | |
431 | |
432 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
433 "SELECT fileType FROM AttachedFiles WHERE id=?"); | |
434 s.BindInt64(0, id); | |
435 | |
436 while (s.Step()) | |
437 { | |
438 target.push_back(static_cast<FileContentType>(s.ColumnInt(0))); | |
439 } | |
440 } | |
441 | |
442 bool DatabaseWrapper::LookupAttachment(FileInfo& attachment, | |
443 int64_t id, | |
444 FileContentType contentType) | |
445 { | |
446 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
447 "SELECT uuid, uncompressedSize, compressionType, compressedSize, uncompressedMD5, compressedMD5 FROM AttachedFiles WHERE id=? AND fileType=?"); | |
448 s.BindInt64(0, id); | |
449 s.BindInt(1, contentType); | |
450 | |
451 if (!s.Step()) | |
452 { | |
453 return false; | |
454 } | |
455 else | |
456 { | |
457 attachment = FileInfo(s.ColumnString(0), | |
458 contentType, | |
459 s.ColumnInt64(1), | |
460 s.ColumnString(4), | |
461 static_cast<CompressionType>(s.ColumnInt(2)), | |
462 s.ColumnInt64(3), | |
463 s.ColumnString(5)); | |
464 return true; | |
465 } | |
466 } | |
467 | |
468 | |
469 void DatabaseWrapper::ClearMainDicomTags(int64_t id) | |
470 { | |
471 { | |
472 SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM DicomIdentifiers WHERE id=?"); | |
473 s.BindInt64(0, id); | |
474 s.Run(); | |
475 } | |
476 | |
477 { | |
478 SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM MainDicomTags WHERE id=?"); | |
479 s.BindInt64(0, id); | |
480 s.Run(); | |
481 } | |
482 } | |
483 | |
484 | |
485 static void SetMainDicomTagsInternal(SQLite::Statement& s, | |
486 int64_t id, | |
487 const DicomTag& tag, | |
488 const std::string& value) | |
489 { | |
490 s.BindInt64(0, id); | |
491 s.BindInt(1, tag.GetGroup()); | |
492 s.BindInt(2, tag.GetElement()); | |
493 s.BindString(3, value); | |
494 s.Run(); | |
495 } | |
496 | |
497 | |
498 void DatabaseWrapper::SetMainDicomTag(int64_t id, | |
499 const DicomTag& tag, | |
500 const std::string& value) | |
501 { | |
502 if (tag.IsIdentifier()) | |
503 { | |
504 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO DicomIdentifiers VALUES(?, ?, ?, ?)"); | |
505 SetMainDicomTagsInternal(s, id, tag, value); | |
506 } | |
507 else | |
508 { | |
509 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO MainDicomTags VALUES(?, ?, ?, ?)"); | |
510 SetMainDicomTagsInternal(s, id, tag, value); | |
511 } | |
512 } | |
513 | |
514 void DatabaseWrapper::GetMainDicomTags(DicomMap& map, | |
515 int64_t id) | |
516 { | |
517 map.Clear(); | |
518 | |
519 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM MainDicomTags WHERE id=?"); | |
520 s.BindInt64(0, id); | |
521 while (s.Step()) | |
522 { | |
523 map.SetValue(s.ColumnInt(1), | |
524 s.ColumnInt(2), | |
525 s.ColumnString(3)); | |
526 } | |
527 | |
528 SQLite::Statement s2(db_, SQLITE_FROM_HERE, "SELECT * FROM DicomIdentifiers WHERE id=?"); | |
529 s2.BindInt64(0, id); | |
530 while (s2.Step()) | |
531 { | |
532 map.SetValue(s2.ColumnInt(1), | |
533 s2.ColumnInt(2), | |
534 s2.ColumnString(3)); | |
535 } | |
536 } | |
537 | |
538 | 221 |
539 bool DatabaseWrapper::GetParentPublicId(std::string& target, | 222 bool DatabaseWrapper::GetParentPublicId(std::string& target, |
540 int64_t id) | 223 int64_t id) |
541 { | 224 { |
542 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b " | 225 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b " |
553 return false; | 236 return false; |
554 } | 237 } |
555 } | 238 } |
556 | 239 |
557 | 240 |
558 void DatabaseWrapper::GetChildrenPublicId(std::list<std::string>& target, | |
559 int64_t id) | |
560 { | |
561 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.publicId FROM Resources AS a, Resources AS b " | |
562 "WHERE a.parentId = b.internalId AND b.internalId = ?"); | |
563 s.BindInt64(0, id); | |
564 | |
565 target.clear(); | |
566 | |
567 while (s.Step()) | |
568 { | |
569 target.push_back(s.ColumnString(0)); | |
570 } | |
571 } | |
572 | |
573 | |
574 void DatabaseWrapper::GetChildrenInternalId(std::list<int64_t>& target, | |
575 int64_t id) | |
576 { | |
577 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT a.internalId FROM Resources AS a, Resources AS b " | |
578 "WHERE a.parentId = b.internalId AND b.internalId = ?"); | |
579 s.BindInt64(0, id); | |
580 | |
581 target.clear(); | |
582 | |
583 while (s.Step()) | |
584 { | |
585 target.push_back(s.ColumnInt64(0)); | |
586 } | |
587 } | |
588 | |
589 | |
590 void DatabaseWrapper::LogChange(int64_t internalId, | |
591 const ServerIndexChange& change) | |
592 { | |
593 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO Changes VALUES(NULL, ?, ?, ?, ?)"); | |
594 s.BindInt(0, change.GetChangeType()); | |
595 s.BindInt64(1, internalId); | |
596 s.BindInt(2, change.GetResourceType()); | |
597 s.BindString(3, change.GetDate()); | |
598 s.Run(); | |
599 } | |
600 | |
601 | |
602 void DatabaseWrapper::GetChangesInternal(std::list<ServerIndexChange>& target, | |
603 bool& done, | |
604 SQLite::Statement& s, | |
605 uint32_t maxResults) | |
606 { | |
607 target.clear(); | |
608 | |
609 while (target.size() < maxResults && s.Step()) | |
610 { | |
611 int64_t seq = s.ColumnInt64(0); | |
612 ChangeType changeType = static_cast<ChangeType>(s.ColumnInt(1)); | |
613 ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(3)); | |
614 const std::string& date = s.ColumnString(4); | |
615 | |
616 int64_t internalId = s.ColumnInt64(2); | |
617 std::string publicId = GetPublicId(internalId); | |
618 | |
619 target.push_back(ServerIndexChange(seq, changeType, resourceType, publicId, date)); | |
620 } | |
621 | |
622 done = !(target.size() == maxResults && s.Step()); | |
623 } | |
624 | |
625 | |
626 void DatabaseWrapper::GetChanges(std::list<ServerIndexChange>& target, | |
627 bool& done, | |
628 int64_t since, | |
629 uint32_t maxResults) | |
630 { | |
631 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes WHERE seq>? ORDER BY seq LIMIT ?"); | |
632 s.BindInt64(0, since); | |
633 s.BindInt(1, maxResults + 1); | |
634 GetChangesInternal(target, done, s, maxResults); | |
635 } | |
636 | |
637 void DatabaseWrapper::GetLastChange(std::list<ServerIndexChange>& target) | |
638 { | |
639 bool done; // Ignored | |
640 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT * FROM Changes ORDER BY seq DESC LIMIT 1"); | |
641 GetChangesInternal(target, done, s, 1); | |
642 } | |
643 | |
644 | |
645 void DatabaseWrapper::LogExportedResource(const ExportedResource& resource) | |
646 { | |
647 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
648 "INSERT INTO ExportedResources VALUES(NULL, ?, ?, ?, ?, ?, ?, ?, ?)"); | |
649 | |
650 s.BindInt(0, resource.GetResourceType()); | |
651 s.BindString(1, resource.GetPublicId()); | |
652 s.BindString(2, resource.GetModality()); | |
653 s.BindString(3, resource.GetPatientId()); | |
654 s.BindString(4, resource.GetStudyInstanceUid()); | |
655 s.BindString(5, resource.GetSeriesInstanceUid()); | |
656 s.BindString(6, resource.GetSopInstanceUid()); | |
657 s.BindString(7, resource.GetDate()); | |
658 s.Run(); | |
659 } | |
660 | |
661 | |
662 void DatabaseWrapper::GetExportedResourcesInternal(std::list<ExportedResource>& target, | |
663 bool& done, | |
664 SQLite::Statement& s, | |
665 uint32_t maxResults) | |
666 { | |
667 target.clear(); | |
668 | |
669 while (target.size() < maxResults && s.Step()) | |
670 { | |
671 int64_t seq = s.ColumnInt64(0); | |
672 ResourceType resourceType = static_cast<ResourceType>(s.ColumnInt(1)); | |
673 std::string publicId = s.ColumnString(2); | |
674 | |
675 ExportedResource resource(seq, | |
676 resourceType, | |
677 publicId, | |
678 s.ColumnString(3), // modality | |
679 s.ColumnString(8), // date | |
680 s.ColumnString(4), // patient ID | |
681 s.ColumnString(5), // study instance UID | |
682 s.ColumnString(6), // series instance UID | |
683 s.ColumnString(7)); // sop instance UID | |
684 | |
685 target.push_back(resource); | |
686 } | |
687 | |
688 done = !(target.size() == maxResults && s.Step()); | |
689 } | |
690 | |
691 | |
692 void DatabaseWrapper::GetExportedResources(std::list<ExportedResource>& target, | |
693 bool& done, | |
694 int64_t since, | |
695 uint32_t maxResults) | |
696 { | |
697 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
698 "SELECT * FROM ExportedResources WHERE seq>? ORDER BY seq LIMIT ?"); | |
699 s.BindInt64(0, since); | |
700 s.BindInt(1, maxResults + 1); | |
701 GetExportedResourcesInternal(target, done, s, maxResults); | |
702 } | |
703 | |
704 | |
705 void DatabaseWrapper::GetLastExportedResource(std::list<ExportedResource>& target) | |
706 { | |
707 bool done; // Ignored | |
708 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
709 "SELECT * FROM ExportedResources ORDER BY seq DESC LIMIT 1"); | |
710 GetExportedResourcesInternal(target, done, s, 1); | |
711 } | |
712 | |
713 | |
714 | |
715 | |
716 int64_t DatabaseWrapper::GetTableRecordCount(const std::string& table) | 241 int64_t DatabaseWrapper::GetTableRecordCount(const std::string& table) |
717 { | 242 { |
718 char buf[128]; | 243 char buf[128]; |
719 sprintf(buf, "SELECT COUNT(*) FROM %s", table.c_str()); | 244 sprintf(buf, "SELECT COUNT(*) FROM %s", table.c_str()); |
720 SQLite::Statement s(db_, buf); | 245 SQLite::Statement s(db_, buf); |
729 | 254 |
730 return c; | 255 return c; |
731 } | 256 } |
732 | 257 |
733 | 258 |
734 uint64_t DatabaseWrapper::GetTotalCompressedSize() | 259 DatabaseWrapper::DatabaseWrapper(const std::string& path) : listener_(NULL), base_(db_) |
735 { | |
736 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(compressedSize) FROM AttachedFiles"); | |
737 s.Run(); | |
738 return static_cast<uint64_t>(s.ColumnInt64(0)); | |
739 } | |
740 | |
741 | |
742 uint64_t DatabaseWrapper::GetTotalUncompressedSize() | |
743 { | |
744 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT SUM(uncompressedSize) FROM AttachedFiles"); | |
745 s.Run(); | |
746 return static_cast<uint64_t>(s.ColumnInt64(0)); | |
747 } | |
748 | |
749 void DatabaseWrapper::GetAllPublicIds(std::list<std::string>& target, | |
750 ResourceType resourceType) | |
751 { | |
752 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE resourceType=?"); | |
753 s.BindInt(0, resourceType); | |
754 | |
755 target.clear(); | |
756 while (s.Step()) | |
757 { | |
758 target.push_back(s.ColumnString(0)); | |
759 } | |
760 } | |
761 | |
762 void DatabaseWrapper::GetAllPublicIds(std::list<std::string>& target, | |
763 ResourceType resourceType, | |
764 size_t since, | |
765 size_t limit) | |
766 { | |
767 if (limit == 0) | |
768 { | |
769 target.clear(); | |
770 return; | |
771 } | |
772 | |
773 SQLite::Statement s(db_, SQLITE_FROM_HERE, "SELECT publicId FROM Resources WHERE resourceType=? LIMIT ? OFFSET ?"); | |
774 s.BindInt(0, resourceType); | |
775 s.BindInt64(1, limit); | |
776 s.BindInt64(2, since); | |
777 | |
778 target.clear(); | |
779 while (s.Step()) | |
780 { | |
781 target.push_back(s.ColumnString(0)); | |
782 } | |
783 } | |
784 | |
785 | |
786 DatabaseWrapper::DatabaseWrapper(const std::string& path) : listener_(NULL) | |
787 { | 260 { |
788 db_.Open(path); | 261 db_.Open(path); |
789 Open(); | 262 Open(); |
790 } | 263 } |
791 | 264 |
792 DatabaseWrapper::DatabaseWrapper() : listener_(NULL) | 265 DatabaseWrapper::DatabaseWrapper() : listener_(NULL), base_(db_) |
793 { | 266 { |
794 db_.OpenInMemory(); | 267 db_.OpenInMemory(); |
795 Open(); | 268 Open(); |
796 } | 269 } |
797 | 270 |
904 listener_ = &listener; | 377 listener_ = &listener; |
905 db_.Register(new Internals::SignalFileDeleted(listener)); | 378 db_.Register(new Internals::SignalFileDeleted(listener)); |
906 db_.Register(new Internals::SignalResourceDeleted(listener)); | 379 db_.Register(new Internals::SignalResourceDeleted(listener)); |
907 } | 380 } |
908 | 381 |
909 uint64_t DatabaseWrapper::GetResourceCount(ResourceType resourceType) | |
910 { | |
911 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
912 "SELECT COUNT(*) FROM Resources WHERE resourceType=?"); | |
913 s.BindInt(0, resourceType); | |
914 | |
915 if (!s.Step()) | |
916 { | |
917 throw OrthancException(ErrorCode_InternalError); | |
918 } | |
919 | |
920 int64_t c = s.ColumnInt(0); | |
921 assert(!s.Step()); | |
922 | |
923 return c; | |
924 } | |
925 | |
926 bool DatabaseWrapper::SelectPatientToRecycle(int64_t& internalId) | |
927 { | |
928 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
929 "SELECT patientId FROM PatientRecyclingOrder ORDER BY seq ASC LIMIT 1"); | |
930 | |
931 if (!s.Step()) | |
932 { | |
933 // No patient remaining or all the patients are protected | |
934 return false; | |
935 } | |
936 else | |
937 { | |
938 internalId = s.ColumnInt(0); | |
939 return true; | |
940 } | |
941 } | |
942 | |
943 bool DatabaseWrapper::SelectPatientToRecycle(int64_t& internalId, | |
944 int64_t patientIdToAvoid) | |
945 { | |
946 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
947 "SELECT patientId FROM PatientRecyclingOrder " | |
948 "WHERE patientId != ? ORDER BY seq ASC LIMIT 1"); | |
949 s.BindInt64(0, patientIdToAvoid); | |
950 | |
951 if (!s.Step()) | |
952 { | |
953 // No patient remaining or all the patients are protected | |
954 return false; | |
955 } | |
956 else | |
957 { | |
958 internalId = s.ColumnInt(0); | |
959 return true; | |
960 } | |
961 } | |
962 | |
963 bool DatabaseWrapper::IsProtectedPatient(int64_t internalId) | |
964 { | |
965 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
966 "SELECT * FROM PatientRecyclingOrder WHERE patientId = ?"); | |
967 s.BindInt64(0, internalId); | |
968 return !s.Step(); | |
969 } | |
970 | |
971 void DatabaseWrapper::SetProtectedPatient(int64_t internalId, | |
972 bool isProtected) | |
973 { | |
974 if (isProtected) | |
975 { | |
976 SQLite::Statement s(db_, SQLITE_FROM_HERE, "DELETE FROM PatientRecyclingOrder WHERE patientId=?"); | |
977 s.BindInt64(0, internalId); | |
978 s.Run(); | |
979 } | |
980 else if (IsProtectedPatient(internalId)) | |
981 { | |
982 SQLite::Statement s(db_, SQLITE_FROM_HERE, "INSERT INTO PatientRecyclingOrder VALUES(NULL, ?)"); | |
983 s.BindInt64(0, internalId); | |
984 s.Run(); | |
985 } | |
986 else | |
987 { | |
988 // Nothing to do: The patient is already unprotected | |
989 } | |
990 } | |
991 | |
992 | |
993 | 382 |
994 void DatabaseWrapper::ClearTable(const std::string& tableName) | 383 void DatabaseWrapper::ClearTable(const std::string& tableName) |
995 { | 384 { |
996 db_.Execute("DELETE FROM " + tableName); | 385 db_.Execute("DELETE FROM " + tableName); |
997 } | |
998 | |
999 | |
1000 bool DatabaseWrapper::IsExistingResource(int64_t internalId) | |
1001 { | |
1002 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
1003 "SELECT * FROM Resources WHERE internalId=?"); | |
1004 s.BindInt64(0, internalId); | |
1005 return s.Step(); | |
1006 } | |
1007 | |
1008 | |
1009 void DatabaseWrapper::LookupIdentifier(std::list<int64_t>& target, | |
1010 const DicomTag& tag, | |
1011 const std::string& value) | |
1012 { | |
1013 if (!tag.IsIdentifier()) | |
1014 { | |
1015 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
1016 } | |
1017 | |
1018 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
1019 "SELECT id FROM DicomIdentifiers WHERE tagGroup=? AND tagElement=? and value=?"); | |
1020 | |
1021 s.BindInt(0, tag.GetGroup()); | |
1022 s.BindInt(1, tag.GetElement()); | |
1023 s.BindString(2, value); | |
1024 | |
1025 target.clear(); | |
1026 | |
1027 while (s.Step()) | |
1028 { | |
1029 target.push_back(s.ColumnInt64(0)); | |
1030 } | |
1031 } | |
1032 | |
1033 | |
1034 void DatabaseWrapper::LookupIdentifier(std::list<int64_t>& target, | |
1035 const std::string& value) | |
1036 { | |
1037 SQLite::Statement s(db_, SQLITE_FROM_HERE, | |
1038 "SELECT id FROM DicomIdentifiers WHERE value=?"); | |
1039 | |
1040 s.BindString(0, value); | |
1041 | |
1042 target.clear(); | |
1043 | |
1044 while (s.Step()) | |
1045 { | |
1046 target.push_back(s.ColumnInt64(0)); | |
1047 } | |
1048 } | 386 } |
1049 | 387 |
1050 | 388 |
1051 void DatabaseWrapper::GetAllMetadata(std::map<MetadataType, std::string>& target, | 389 void DatabaseWrapper::GetAllMetadata(std::map<MetadataType, std::string>& target, |
1052 int64_t id) | 390 int64_t id) |