Mercurial > hg > orthanc-databases

comparison SQLite/Plugins/IndexPlugin.cpp @ 209:13a3863df7fa

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cont
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 19 Mar 2021 17:01:38 +0100
parents 696bc0c9fddb
children a0c095a4ba7d
comparison
equal deleted inserted replaced
208:696bc0c9fddb 209:13a3863df7fa
101 } 101 }
102 102
103 103
104 void Clear() 104 void Clear()
105 { 105 {
106 // We don't systematically clear all the vectors, in order to
107 // avoid spending unnecessary time
108
109 switch (answerType_)
110 {
111 case _OrthancPluginDatabaseAnswerType_None:
112 break;
113
114 case _OrthancPluginDatabaseAnswerType_Attachment:
115 attachments_.clear();
116 break;
117
118 case _OrthancPluginDatabaseAnswerType_Change:
119 changes_.clear();
120 break;
121
122 case _OrthancPluginDatabaseAnswerType_DicomTag:
123 tags_.clear();
124 break;
125
126 case _OrthancPluginDatabaseAnswerType_ExportedResource:
127 exported_.clear();
128 break;
129
130 case _OrthancPluginDatabaseAnswerType_Int32:
131 integers32_.clear();
132 break;
133
134 case _OrthancPluginDatabaseAnswerType_Int64:
135 integers64_.clear();
136 break;
137
138 case _OrthancPluginDatabaseAnswerType_MatchingResource:
139 matches_.clear();
140 break;
141
142 case _OrthancPluginDatabaseAnswerType_Metadata:
143 metadata_.clear();
144 break;
145
146 case _OrthancPluginDatabaseAnswerType_String:
147 stringAnswers_.clear();
148 break;
149
150 default:
151 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
152 }
153
106 answerType_ = _OrthancPluginDatabaseAnswerType_None; 154 answerType_ = _OrthancPluginDatabaseAnswerType_None;
107 stringsStore_.clear(); 155 stringsStore_.clear();
108 156
109 attachments_.clear(); 157 assert(attachments_.empty());
110 changes_.clear(); 158 assert(changes_.empty());
111 tags_.clear(); 159 assert(tags_.empty());
112 exported_.clear(); 160 assert(exported_.empty());
113 events_.clear(); 161 assert(events_.empty());
114 integers32_.clear(); 162 assert(integers32_.empty());
115 integers64_.clear(); 163 assert(integers64_.empty());
116 matches_.clear(); 164 assert(matches_.empty());
117 metadata_.clear(); 165 assert(metadata_.empty());
118 stringAnswers_.clear(); 166 assert(stringAnswers_.empty());
119 } 167 }
120 168
121 169
122 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction, 170 static OrthancPluginErrorCode ReadAnswersCount(OrthancPluginDatabaseTransaction* transaction,
123 uint32_t* target /* out */) 171 uint32_t* target /* out */)
194 } 242 }
195 } 243 }
196 244
197 245
198 static OrthancPluginErrorCode ReadAnswerChange(OrthancPluginDatabaseTransaction* transaction, 246 static OrthancPluginErrorCode ReadAnswerChange(OrthancPluginDatabaseTransaction* transaction,
199 OrthancPluginChange* target /* out */, 247 OrthancPluginChange* target /* out */,
200 uint32_t index) 248 uint32_t index)
201 { 249 {
202 const Output& that = *reinterpret_cast<const Output*>(transaction); 250 const Output& that = *reinterpret_cast<const Output*>(transaction);
203 251
204 if (index < that.changes_.size()) 252 if (index < that.changes_.size())
205 { 253 {
565 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String); 613 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String);
566 614
567 stringAnswers_.reserve(values.size()); 615 stringAnswers_.reserve(values.size());
568 std::copy(std::begin(values), std::end(values), std::back_inserter(stringAnswers_)); 616 std::copy(std::begin(values), std::end(values), std::back_inserter(stringAnswers_));
569 } 617 }
618
619
620 void AnswerString(const std::string& value)
621 {
622 SetupAnswerType(_OrthancPluginDatabaseAnswerType_String);
623
624 if (stringAnswers_.empty())
625 {
626 stringAnswers_.push_back(value);
627 }
628 else
629 {
630 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
631 }
632 }
570 }; 633 };
571 634
572 635
573 class Factory : public IDatabaseBackendOutput::IFactory 636 class Factory : public IDatabaseBackendOutput::IFactory
574 { 637 {
585 648
586 649
587 class Transaction : public boost::noncopyable 650 class Transaction : public boost::noncopyable
588 { 651 {
589 private: 652 private:
590 IDatabaseBackend& backend_; 653 boost::mutex::scoped_lock lock_; // TODO - REMOVE
591 std::unique_ptr<Output> output_; 654 IDatabaseBackend& backend_;
592 655 std::unique_ptr<Output> output_;
656
657 static boost::mutex& GetMutex() // TODO - REMOVE
658 {
659 static boost::mutex mutex_;
660 return mutex_;
661 }
662
593 public: 663 public:
594 Transaction(IDatabaseBackend& backend) : 664 Transaction(IDatabaseBackend& backend) :
665 lock_(GetMutex()),
595 backend_(backend), 666 backend_(backend),
596 output_(new Output) 667 output_(new Output)
597 { 668 {
598 } 669 }
599 670
963 } 1034 }
964 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext()); 1035 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
965 } 1036 }
966 1037
967 1038
1039 static OrthancPluginErrorCode GetChildrenInternalId(OrthancPluginDatabaseTransaction* transaction,
1040 int64_t id)
1041 {
1042 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1043
1044 try
1045 {
1046 t->GetOutput().Clear();
1047
1048 std::list<int64_t> values;
1049 t->GetBackend().GetChildrenInternalId(values, id);
1050 t->GetOutput().AnswerIntegers64(values);
1051
1052 return OrthancPluginErrorCode_Success;
1053 }
1054 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1055 }
1056
1057
1058 static OrthancPluginErrorCode GetChildrenMetadata(OrthancPluginDatabaseTransaction* transaction,
1059 int64_t resourceId,
1060 int32_t metadata)
1061 {
1062 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1063
1064 try
1065 {
1066 t->GetOutput().Clear();
1067
1068 std::list<std::string> values;
1069 t->GetBackend().GetChildrenMetadata(values, resourceId, metadata);
1070 t->GetOutput().AnswerStrings(values);
1071
1072 return OrthancPluginErrorCode_Success;
1073 }
1074 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1075 }
1076
1077
1078 static OrthancPluginErrorCode GetChildrenPublicId(OrthancPluginDatabaseTransaction* transaction,
1079 int64_t id)
1080 {
1081 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1082
1083 try
1084 {
1085 t->GetOutput().Clear();
1086
1087 std::list<std::string> values;
1088 t->GetBackend().GetChildrenPublicId(values, id);
1089 t->GetOutput().AnswerStrings(values);
1090
1091 return OrthancPluginErrorCode_Success;
1092 }
1093 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1094 }
1095
1096
1097 static OrthancPluginErrorCode GetExportedResources(OrthancPluginDatabaseTransaction* transaction,
1098 uint8_t* targetDone /* out */,
1099 int64_t since,
1100 uint32_t maxResults)
1101 {
1102 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1103
1104 try
1105 {
1106 t->GetOutput().Clear();
1107
1108 bool done;
1109 t->GetBackend().GetExportedResources(t->GetOutput(), done, since, maxResults);
1110 *targetDone = (done ? 1 : 0);
1111
1112 return OrthancPluginErrorCode_Success;
1113 }
1114 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1115 }
1116
1117
1118 static OrthancPluginErrorCode GetLastChange(OrthancPluginDatabaseTransaction* transaction)
1119 {
1120 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1121
1122 try
1123 {
1124 t->GetOutput().Clear();
1125 t->GetBackend().GetLastChange(t->GetOutput());
1126 return OrthancPluginErrorCode_Success;
1127 }
1128 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1129 }
1130
1131
1132 static OrthancPluginErrorCode GetLastChangeIndex(OrthancPluginDatabaseTransaction* transaction,
1133 int64_t* target)
1134 {
1135 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1136
1137 try
1138 {
1139 t->GetOutput().Clear();
1140 *target = t->GetBackend().GetLastChangeIndex();
1141 return OrthancPluginErrorCode_Success;
1142 }
1143 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1144 }
1145
1146
1147 static OrthancPluginErrorCode GetLastExportedResource(OrthancPluginDatabaseTransaction* transaction)
1148 {
1149 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1150
1151 try
1152 {
1153 t->GetOutput().Clear();
1154 t->GetBackend().GetLastExportedResource(t->GetOutput());
1155 return OrthancPluginErrorCode_Success;
1156 }
1157 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1158 }
1159
1160
1161 static OrthancPluginErrorCode GetMainDicomTags(OrthancPluginDatabaseTransaction* transaction,
1162 int64_t id)
1163 {
1164 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1165
1166 try
1167 {
1168 t->GetOutput().Clear();
1169 t->GetBackend().GetMainDicomTags(t->GetOutput(), id);
1170 return OrthancPluginErrorCode_Success;
1171 }
1172 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1173 }
1174
1175
1176 static OrthancPluginErrorCode GetPublicId(OrthancPluginDatabaseTransaction* transaction,
1177 int64_t id)
1178 {
1179 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1180
1181 try
1182 {
1183 t->GetOutput().Clear();
1184 t->GetOutput().AnswerString(t->GetBackend().GetPublicId(id));
1185 return OrthancPluginErrorCode_Success;
1186 }
1187 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1188 }
1189
1190
1191 static OrthancPluginErrorCode GetResourcesCount(OrthancPluginDatabaseTransaction* transaction,
1192 uint64_t* target /* out */,
1193 OrthancPluginResourceType resourceType)
1194 {
1195 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1196
1197 try
1198 {
1199 t->GetOutput().Clear();
1200 *target = t->GetBackend().GetResourcesCount(resourceType);
1201 return OrthancPluginErrorCode_Success;
1202 }
1203 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1204 }
1205
1206
1207 static OrthancPluginErrorCode GetResourceType(OrthancPluginDatabaseTransaction* transaction,
1208 OrthancPluginResourceType* target /* out */,
1209 uint64_t resourceId)
1210 {
1211 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1212
1213 try
1214 {
1215 t->GetOutput().Clear();
1216 *target = t->GetBackend().GetResourceType(resourceId);
1217 return OrthancPluginErrorCode_Success;
1218 }
1219 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1220 }
1221
1222
1223 static OrthancPluginErrorCode GetTotalCompressedSize(OrthancPluginDatabaseTransaction* transaction,
1224 uint64_t* target /* out */)
1225 {
1226 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1227
1228 try
1229 {
1230 t->GetOutput().Clear();
1231 *target = t->GetBackend().GetTotalCompressedSize();
1232 return OrthancPluginErrorCode_Success;
1233 }
1234 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1235 }
1236
1237
1238 static OrthancPluginErrorCode GetTotalUncompressedSize(OrthancPluginDatabaseTransaction* transaction,
1239 uint64_t* target /* out */)
1240 {
1241 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1242
1243 try
1244 {
1245 t->GetOutput().Clear();
1246 *target = t->GetBackend().GetTotalUncompressedSize();
1247 return OrthancPluginErrorCode_Success;
1248 }
1249 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1250 }
1251
1252
1253 static OrthancPluginErrorCode IsDiskSizeAbove(OrthancPluginDatabaseTransaction* transaction,
1254 uint8_t* target,
1255 uint64_t threshold)
1256 {
1257 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1258
1259 try
1260 {
1261 t->GetOutput().Clear();
1262 bool above = (t->GetBackend().GetTotalCompressedSize() >= threshold);
1263 *target = (above ? 1 : 0);
1264 return OrthancPluginErrorCode_Success;
1265 }
1266 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1267 }
1268
1269
1270 static OrthancPluginErrorCode IsExistingResource(OrthancPluginDatabaseTransaction* transaction,
1271 uint8_t* target,
1272 int64_t resourceId)
1273 {
1274 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1275
1276 try
1277 {
1278 t->GetOutput().Clear();
1279 bool exists = t->GetBackend().IsExistingResource(resourceId);
1280 *target = (exists ? 1 : 0);
1281 return OrthancPluginErrorCode_Success;
1282 }
1283 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1284 }
1285
1286
1287 static OrthancPluginErrorCode IsProtectedPatient(OrthancPluginDatabaseTransaction* transaction,
1288 uint8_t* target,
1289 int64_t resourceId)
1290 {
1291 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1292
1293 try
1294 {
1295 t->GetOutput().Clear();
1296 bool isProtected = t->GetBackend().IsProtectedPatient(resourceId);
1297 *target = (isProtected ? 1 : 0);
1298 return OrthancPluginErrorCode_Success;
1299 }
1300 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1301 }
1302
1303
1304 static OrthancPluginErrorCode ListAvailableAttachments(OrthancPluginDatabaseTransaction* transaction,
1305 int64_t resourceId)
1306 {
1307 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1308
1309 try
1310 {
1311 t->GetOutput().Clear();
1312
1313 std::list<int32_t> values;
1314 t->GetBackend().ListAvailableAttachments(values, resourceId);
1315 t->GetOutput().AnswerIntegers32(values);
1316 return OrthancPluginErrorCode_Success;
1317 }
1318 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1319 }
1320
1321
1322 static OrthancPluginErrorCode LogChange(OrthancPluginDatabaseTransaction* transaction,
1323 int32_t changeType,
1324 int64_t resourceId,
1325 OrthancPluginResourceType resourceType,
1326 const char* date)
1327 {
1328 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1329
1330 try
1331 {
1332 t->GetOutput().Clear();
1333 t->GetBackend().LogChange(changeType, resourceId, resourceType, date);
1334 return OrthancPluginErrorCode_Success;
1335 }
1336 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1337 }
1338
1339
1340 static OrthancPluginErrorCode LogExportedResource(OrthancPluginDatabaseTransaction* transaction,
1341 OrthancPluginResourceType resourceType,
1342 const char* publicId,
1343 const char* modality,
1344 const char* date,
1345 const char* patientId,
1346 const char* studyInstanceUid,
1347 const char* seriesInstanceUid,
1348 const char* sopInstanceUid)
1349 {
1350 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1351
1352 try
1353 {
1354 OrthancPluginExportedResource exported;
1355 exported.seq = 0;
1356 exported.resourceType = resourceType;
1357 exported.publicId = publicId;
1358 exported.modality = modality;
1359 exported.date = date;
1360 exported.patientId = patientId;
1361 exported.studyInstanceUid = studyInstanceUid;
1362 exported.seriesInstanceUid = seriesInstanceUid;
1363 exported.sopInstanceUid = sopInstanceUid;
1364
1365 t->GetOutput().Clear();
1366 t->GetBackend().LogExportedResource(exported);
1367 return OrthancPluginErrorCode_Success;
1368 }
1369 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1370 }
1371
1372
1373 static OrthancPluginErrorCode LookupAttachment(OrthancPluginDatabaseTransaction* transaction,
1374 int64_t resourceId,
1375 int32_t contentType)
1376 {
1377 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1378
1379 try
1380 {
1381 t->GetOutput().Clear();
1382 t->GetBackend().LookupAttachment(t->GetOutput(), resourceId, contentType);
1383 return OrthancPluginErrorCode_Success;
1384 }
1385 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1386 }
1387
1388
1389 static OrthancPluginErrorCode LookupGlobalProperty(OrthancPluginDatabaseTransaction* transaction,
1390 int32_t property)
1391 {
1392 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1393
1394 try
1395 {
1396 t->GetOutput().Clear();
1397
1398 std::string s;
1399 if (t->GetBackend().LookupGlobalProperty(s, property))
1400 {
1401 t->GetOutput().AnswerString(s);
1402 }
1403
1404 return OrthancPluginErrorCode_Success;
1405 }
1406 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1407 }
1408
1409
1410 static OrthancPluginErrorCode LookupMetadata(OrthancPluginDatabaseTransaction* transaction,
1411 int64_t id,
1412 int32_t metadata)
1413 {
1414 Transaction* t = reinterpret_cast<Transaction*>(transaction);
1415
1416 try
1417 {
1418 t->GetOutput().Clear();
1419
1420 std::string s;
1421 if (t->GetBackend().LookupMetadata(s, id, metadata))
1422 {
1423 t->GetOutput().AnswerString(s);
1424 }
1425
1426 return OrthancPluginErrorCode_Success;
1427 }
1428 ORTHANC_PLUGINS_DATABASE_CATCH(t->GetContext());
1429 }
1430
968 1431
969 static void RegisterV3(IDatabaseBackend& database) 1432 static void RegisterV3(IDatabaseBackend& database)
970 { 1433 {
971 OrthancPluginDatabaseBackendV3 params; 1434 OrthancPluginDatabaseBackendV3 params;
972 memset(&params, 0, sizeof(params)); 1435 memset(&params, 0, sizeof(params));
1005 params.deleteResource = DeleteResource; 1468 params.deleteResource = DeleteResource;
1006 params.getAllMetadata = GetAllMetadata; 1469 params.getAllMetadata = GetAllMetadata;
1007 params.getAllPublicIds = GetAllPublicIds; 1470 params.getAllPublicIds = GetAllPublicIds;
1008 params.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit; 1471 params.getAllPublicIdsWithLimit = GetAllPublicIdsWithLimit;
1009 params.getChanges = GetChanges; 1472 params.getChanges = GetChanges;
1473 params.getChildrenInternalId = GetChildrenInternalId;
1474 params.getChildrenMetadata = GetChildrenMetadata;
1475 params.getChildrenPublicId = GetChildrenPublicId;
1476 params.getExportedResources = GetExportedResources;
1477 params.getLastChange = GetLastChange;
1478 params.getLastChangeIndex = GetLastChangeIndex;
1479 params.getLastExportedResource = GetLastExportedResource;
1480 params.getMainDicomTags = GetMainDicomTags;
1481 params.getPublicId = GetPublicId;
1482 params.getResourcesCount = GetResourcesCount;
1483 params.getResourceType = GetResourceType;
1484 params.getTotalCompressedSize = GetTotalCompressedSize;
1485 params.getTotalUncompressedSize = GetTotalUncompressedSize;
1486 params.isDiskSizeAbove = IsDiskSizeAbove;
1487 params.isExistingResource = IsExistingResource;
1488 params.isProtectedPatient = IsProtectedPatient;
1489 params.listAvailableAttachments = ListAvailableAttachments;
1490 params.logChange = LogChange;
1491 params.logExportedResource = LogExportedResource;
1492 params.lookupAttachment = LookupAttachment;
1493 params.lookupGlobalProperty = LookupGlobalProperty;
1494 params.lookupMetadata = LookupMetadata;
1010 1495
1011 OrthancPluginContext* context = database.GetContext(); 1496 OrthancPluginContext* context = database.GetContext();
1012 1497
1013 if (OrthancPluginRegisterDatabaseBackendV3(context, &params, sizeof(params), &database) != OrthancPluginErrorCode_Success) 1498 if (OrthancPluginRegisterDatabaseBackendV3(context, &params, sizeof(params), &database) != OrthancPluginErrorCode_Success)
1014 { 1499 {