Mercurial > hg > orthanc

comparison OrthancServer/DatabaseWrapper.cpp @ 1670:16955f8fec4d db-changes

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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)