Belle II Software development
database.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8#include <framework/database/IntervalOfValidity.h>
9#include <framework/database/Database.h>
10#include <framework/database/Configuration.h>
11#include <framework/database/DBObjPtr.h>
12#include <framework/database/DBArray.h>
13#include <framework/database/EventDependency.h>
14#include <framework/database/PayloadFile.h>
15#include <framework/database/DBPointer.h>
16#include <framework/datastore/StoreObjPtr.h>
17#include <framework/dataobjects/EventMetaData.h>
18#include <framework/utilities/TestHelpers.h>
19#include <framework/geometry/BFieldManager.h>
20#include <framework/dbobjects/MagneticField.h>
21#include <framework/dbobjects/MagneticFieldComponentConstant.h>
22
23#include <TNamed.h>
24#include <TClonesArray.h>
25
26#include <gtest/gtest.h>
27
28#include <filesystem>
29#include <list>
30#include <cstdio>
31
32using namespace std;
33using namespace Belle2;
34
35namespace {
36
38 class DataBaseTest : public ::testing::Test {
39 protected:
40
42 enum EDatabaseType {c_local, c_central, c_chain, c_default};
43
45 EDatabaseType m_dbType = c_local;
46
47 TestHelpers::TempDirCreator m_tempDir;
50 void SetUp() override
51 {
52 StoreObjPtr<EventMetaData> evtPtr;
53 DataStore::Instance().setInitializeActive(true);
54 evtPtr.registerInDataStore();
55 DataStore::Instance().setInitializeActive(false);
56 evtPtr.construct(0, 0, 1);
57
58 auto& c = Conditions::Configuration::getInstance();
59 switch (m_dbType) {
60 case c_local:
61 c.setGlobalTags({});
62 c.overrideGlobalTags();
63 c.setMetadataProviders({});
64 c.setNewPayloadLocation("testPayloads/TestDatabase.txt");
65 c.appendTestingPayloadLocation("testPayloads/TestDatabase.txt");
66 break;
67 case c_central:
68 c.setGlobalTags({"default"});
69 c.overrideGlobalTags();
70 break;
71 case c_chain:
72 c.setGlobalTags({"default"});
73 c.overrideGlobalTags();
74 c.setMetadataProviders({});
75 c.setNewPayloadLocation("testPayloads/TestDatabase.txt");
76 c.appendTestingPayloadLocation("testPayloads/TestDatabase.txt");
77 break;
78 case c_default:
79 break;
80 }
81
82 if (m_dbType != c_central) {
83 list<Database::DBImportQuery> query;
84 TClonesArray array("TObject");
85 for (int experiment = 1; experiment <= 5; experiment++) {
86 IntervalOfValidity iov(experiment, -1, experiment, -1);
87
88 TString name = "Experiment ";
89 name += experiment;
90 query.push_back(Database::DBImportQuery("TNamed", new TNamed(name, name), iov));
91
92 new (array[experiment - 1]) TObject;
93 array[experiment - 1]->SetUniqueID(experiment);
94 Database::Instance().storeData("TObjects", &array, iov);
95
96 FILE* f = fopen("file.xml", "w");
97 fprintf(f, "Experiment %d\n", experiment);
98 fclose(f);
99 Database::Instance().addPayload("file.xml", "file.xml", iov);
100 }
101 if (m_dbType != c_chain) {
102 Database::Instance().storeData(query);
103 }
104
105 EventDependency intraRunDep(new TNamed("A", "A"));
106 intraRunDep.add(10, new TNamed("B", "B"));
107 intraRunDep.add(50, new TNamed("C", "C"));
108 IntervalOfValidity iov1(1, 1, 1, 1);
109 Database::Instance().storeData("IntraRun", &intraRunDep, iov1);
110 IntervalOfValidity iov2(1, 2, 1, -1);
111 Database::Instance().storeData("IntraRun", new TNamed("X", "X"), iov2);
112 }
113 }
114
116 void TearDown() override
117 {
118 if (m_dbType != c_central) std::filesystem::remove_all("testPayloads");
119 Database::reset();
120 DataStore::Instance().reset();
121 }
122
123 };
124
126 TEST_F(DataBaseTest, IntervalOfValidity)
127 {
128 EXPECT_TRUE(IntervalOfValidity().empty());
129 EXPECT_FALSE(IntervalOfValidity(1, -1, -1, -1).empty());
130 EXPECT_FALSE(IntervalOfValidity(-1, -1, 1, -1).empty());
131 EXPECT_FALSE(IntervalOfValidity(1, 2, 3, 4).empty());
132
133 EventMetaData event(0, 8, 15); // experiment 15, run 8
134 EXPECT_FALSE(IntervalOfValidity().contains(event));
135 EXPECT_FALSE(IntervalOfValidity(16, 1, -1, -1).contains(event));
136 EXPECT_FALSE(IntervalOfValidity(16, -1, -1, -1).contains(event));
137 EXPECT_FALSE(IntervalOfValidity(15, 9, -1, -1).contains(event));
138 EXPECT_TRUE(IntervalOfValidity(15, 8, -1, -1).contains(event));
139 EXPECT_TRUE(IntervalOfValidity(15, 8, 15, -1).contains(event));
140 EXPECT_TRUE(IntervalOfValidity(15, 8, 15, 8).contains(event));
141 EXPECT_TRUE(IntervalOfValidity(15, -1, 15, 8).contains(event));
142 EXPECT_TRUE(IntervalOfValidity(-1, -1, 15, 8).contains(event));
143 EXPECT_FALSE(IntervalOfValidity(-1, -1, 15, 7).contains(event));
144 EXPECT_FALSE(IntervalOfValidity(-1, -1, 14, -1).contains(event));
145 EXPECT_FALSE(IntervalOfValidity(-1, -1, 14, 1).contains(event));
146 }
147
149 TEST_F(DataBaseTest, IntervalOfValidityOperations)
150 {
151 IntervalOfValidity iov(1, 1, 3, 10);
152 EXPECT_TRUE(IntervalOfValidity(1, 1, 3, 10).contains(iov));
153 EXPECT_TRUE(IntervalOfValidity(1, -1, 3, 10).contains(iov));
154 EXPECT_TRUE(IntervalOfValidity(-1, -1, 3, 10).contains(iov));
155 EXPECT_TRUE(IntervalOfValidity(1, 1, 3, -1).contains(iov));
156 EXPECT_TRUE(IntervalOfValidity(1, 1, -1, -1).contains(iov));
157 EXPECT_FALSE(IntervalOfValidity(1, 2, 3, 10).contains(iov));
158 EXPECT_FALSE(IntervalOfValidity(2, -1, 3, 10).contains(iov));
159 EXPECT_FALSE(IntervalOfValidity(1, 1, 3, 9).contains(iov));
160 EXPECT_FALSE(IntervalOfValidity(1, 1, 2, -1).contains(iov));
161 EXPECT_TRUE(iov.contains(IntervalOfValidity(2, -1, 2, -1)));
162 EXPECT_FALSE(iov.contains(IntervalOfValidity(1, -1, 2, 1)));
163 EXPECT_FALSE(iov.contains(IntervalOfValidity(-1, -1, 3, 10)));
164 EXPECT_FALSE(iov.contains(IntervalOfValidity(1, 1, 3, -1)));
165 EXPECT_FALSE(iov.contains(IntervalOfValidity(1, 1, -1, -1)));
166
167 EXPECT_TRUE(IntervalOfValidity(1, 1, 3, 10).overlaps(iov));
168 EXPECT_TRUE(IntervalOfValidity(1, -1, 1, 1).overlaps(iov));
169 EXPECT_TRUE(IntervalOfValidity(-1, -1, 1, 1).overlaps(iov));
170 EXPECT_TRUE(IntervalOfValidity(-1, -1, 1, -1).overlaps(iov));
171 EXPECT_TRUE(IntervalOfValidity(3, -1, -1, -1).overlaps(iov));
172 EXPECT_TRUE(IntervalOfValidity(3, 10, -1, -1).overlaps(iov));
173 EXPECT_FALSE(IntervalOfValidity(-1, -1, -1, -1).overlaps(iov));
174 EXPECT_FALSE(IntervalOfValidity(-1, -1, 0, -1).overlaps(iov));
175 EXPECT_FALSE(IntervalOfValidity(-1, -1, 1, 0).overlaps(iov));
176 EXPECT_FALSE(IntervalOfValidity(3, 11, 3, -1).overlaps(iov));
177 EXPECT_FALSE(IntervalOfValidity(4, -1, 4, -1).overlaps(iov));
178
179 IntervalOfValidity iov1, iov2;
180 iov1 = IntervalOfValidity(1, 1, 3, 10);
181 iov2 = IntervalOfValidity(1, 1, 3, 10);
182 EXPECT_TRUE(iov1.trimOverlap(iov2, true));
183 EXPECT_TRUE(iov1.empty());
184 EXPECT_TRUE(iov2 == IntervalOfValidity(1, 1, 3, 10));
185
186 iov1 = IntervalOfValidity(1, 1, 3, 10);
187 iov2 = IntervalOfValidity(2, -1, 4, -1);
188 EXPECT_TRUE(iov1.trimOverlap(iov2, true));
189 EXPECT_TRUE(iov1 == IntervalOfValidity(1, 1, 1, -1));
190 EXPECT_TRUE(iov2 == IntervalOfValidity(2, -1, 4, -1));
191
192 iov1 = IntervalOfValidity(1, 1, 3, 11);
193 iov2 = IntervalOfValidity(1, 1, 3, 10);
194 EXPECT_FALSE(iov1.trimOverlap(iov2, true));
195 EXPECT_TRUE(iov1 == IntervalOfValidity(1, 1, 3, 11));
196 EXPECT_TRUE(iov2 == IntervalOfValidity(1, 1, 3, 10));
197
198 iov1 = IntervalOfValidity(1, 1, 3, 10);
199 iov2 = IntervalOfValidity(1, 1, 3, 10);
200 EXPECT_TRUE(iov1.trimOverlap(iov2, false));
201 EXPECT_TRUE(iov1 == IntervalOfValidity(1, 1, 3, 10));
202 EXPECT_TRUE(iov2.empty());
203
204 iov1 = IntervalOfValidity(1, 1, 3, 10);
205 iov2 = IntervalOfValidity(2, -1, 4, -1);
206 EXPECT_TRUE(iov1.trimOverlap(iov2, false));
207 EXPECT_TRUE(iov1 == IntervalOfValidity(1, 1, 3, 10));
208 EXPECT_TRUE(iov2 == IntervalOfValidity(3, 11, 4, -1));
209
210 // Validity is larger than we want on the lower edge
211 iov1 = IntervalOfValidity(11, 0, 12, 86);
212 // Want to trim off everything below exp=12
213 iov2 = IntervalOfValidity(0, 0, 11, -1);
214 EXPECT_TRUE(iov1.trimOverlap(iov2, false));
215 EXPECT_EQ(iov1, IntervalOfValidity(12, 0, 12, 86));
216 EXPECT_EQ(iov2, IntervalOfValidity(0, 0, 11, -1));
217 }
218
220 TEST_F(DataBaseTest, getData)
221 {
222 EXPECT_TRUE(strcmp(Database::Instance().getData("TNamed", 1, 1)->GetName(), "Experiment 1") == 0);
223 EXPECT_TRUE(strcmp(Database::Instance().getData("TNamed", 4, 1)->GetName(), "Experiment 4") == 0);
224 EXPECT_TRUE(Database::Instance().getData("TNamed", 6, 1) == 0);
225 }
226
228 TEST_F(DataBaseTest, DBObjPtr)
229 {
230 StoreObjPtr<EventMetaData> evtPtr;
231 DBObjPtr<TNamed> named;
232
233 evtPtr->setExperiment(1);
234 DBStore::Instance().update();
235 ASSERT_TRUE(named);
236 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 1") == 0);
237 evtPtr->setExperiment(4);
238 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 1") == 0);
239 DBStore::Instance().update();
240 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 4") == 0);
241 evtPtr->setExperiment(7);
242 DBStore::Instance().update();
243 EXPECT_FALSE(named);
244 }
245
247 TEST_F(DataBaseTest, DBArray)
248 {
249 StoreObjPtr<EventMetaData> evtPtr;
250 DBArray<TObject> objects;
251 DBArray<TObject> missing("notexisting");
252 // check iteration on fresh object
253 {
254 int i = 0;
255 for (const auto& o : missing) {
256 (void)o;
257 ++i;
258 }
259 EXPECT_EQ(i, 0);
260 }
261
262
263 evtPtr->setExperiment(1);
264 DBStore::Instance().update();
265 EXPECT_TRUE(objects);
266 EXPECT_FALSE(missing);
267 EXPECT_EQ(objects.getEntries(), 1);
268 EXPECT_EQ(objects[0]->GetUniqueID(), 1);
269 evtPtr->setExperiment(4);
270 EXPECT_EQ(objects.getEntries(), 1);
271 DBStore::Instance().update();
272 EXPECT_EQ(objects.getEntries(), 4);
273 // check iteration on existing
274 {
275 int i = 0;
276 for (const auto& o : objects) {
277 EXPECT_EQ(o.GetUniqueID(), ++i);
278 }
279 EXPECT_EQ(i, 4);
280 }
281
282 // check iteration on missing object
283 {
284 int i = 0;
285 for (const auto& o : missing) {
286 (void)o;
287 ++i;
288 }
289 EXPECT_EQ(i, 0);
290 }
291 evtPtr->setExperiment(7);
292 DBStore::Instance().update();
293 EXPECT_FALSE(objects);
294 // check iteration over missing but previously existing
295 {
296 int i = 0;
297 for (const auto& o : objects) {
298 EXPECT_EQ(o.GetUniqueID(), ++i);
299 }
300 EXPECT_EQ(i, 0);
301 }
302 }
303
305 TEST_F(DataBaseTest, DBArrayRange)
306 {
307 StoreObjPtr<EventMetaData> evtPtr;
308 DBArray<TObject> objects;
309
310 evtPtr->setExperiment(3);
311 DBStore::Instance().update();
312 EXPECT_THROW(objects[-1], std::out_of_range);
313 EXPECT_THROW(objects[3], std::out_of_range);
314 }
315
317 TEST_F(DataBaseTest, TypeCheck)
318 {
319 DBObjPtr<TNamed> named;
320 EXPECT_B2FATAL(DBObjPtr<EventMetaData> wrongType("TNamed"));
321
322 DBArray<TObject> objects;
323 EXPECT_B2FATAL(DBArray<EventMetaData> wrongType("TObjects"));
324 }
325
327 TEST_F(DataBaseTest, IntraRun)
328 {
329 StoreObjPtr<EventMetaData> evtPtr;
330 DBObjPtr<TNamed> intraRun("IntraRun");
331
332 evtPtr->setExperiment(1);
333 evtPtr->setRun(1);
334 evtPtr->setEvent(9);
335 DBStore::Instance().update();
336 DBStore::Instance().updateEvent();
337 EXPECT_TRUE(strcmp(intraRun->GetName(), "A") == 0);
338
339 evtPtr->setEvent(10);
340 DBStore::Instance().updateEvent();
341 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
342
343 evtPtr->setEvent(49);
344 DBStore::Instance().updateEvent();
345 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
346
347 //let's run an update in between and make sure intra run continues to work
348 DBStore::Instance().update();
349 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
350
351 evtPtr->setEvent(50);
352 DBStore::Instance().updateEvent();
353 EXPECT_TRUE(strcmp(intraRun->GetName(), "C") == 0);
354
355 evtPtr->setRun(2);
356 DBStore::Instance().update();
357 EXPECT_TRUE(strcmp(intraRun->GetName(), "X") == 0);
358 }
359
361 TEST_F(DataBaseTest, HasChanged)
362 {
363 StoreObjPtr<EventMetaData> evtPtr;
364 evtPtr->setExperiment(0);
365 DBStore::Instance().update();
366
367 DBObjPtr<TNamed> named;
368 EXPECT_FALSE(named.hasChanged());
369
370 evtPtr->setExperiment(1);
371 EXPECT_FALSE(named.hasChanged());
372
373 DBStore::Instance().update();
374 EXPECT_TRUE(named.hasChanged());
375
376 evtPtr->setRun(8);
377 DBStore::Instance().update();
378 EXPECT_FALSE(named.hasChanged());
379
380 evtPtr->setExperiment(5);
381 DBStore::Instance().update();
382 EXPECT_TRUE(named.hasChanged());
383
384 evtPtr->setExperiment(7);
385 DBStore::Instance().update();
386 EXPECT_TRUE(named.hasChanged());
387
388 evtPtr->setExperiment(1);
389 evtPtr->setRun(1);
390 evtPtr->setEvent(1);
391 DBObjPtr<TNamed> intraRun("IntraRun");
392 DBStore::Instance().update();
393 DBStore::Instance().updateEvent();
394 EXPECT_TRUE(intraRun.hasChanged());
395
396 evtPtr->setEvent(2);
397 DBStore::Instance().updateEvent();
398 EXPECT_FALSE(intraRun.hasChanged());
399
400 evtPtr->setEvent(10);
401 DBStore::Instance().updateEvent();
402 EXPECT_TRUE(intraRun.hasChanged());
403
404 evtPtr->setEvent(1000);
405 DBStore::Instance().updateEvent();
406 EXPECT_TRUE(intraRun.hasChanged());
407
408 evtPtr->setRun(4);
409 DBStore::Instance().update();
410 DBStore::Instance().updateEvent();
411 EXPECT_TRUE(intraRun.hasChanged());
412 }
413
415 TEST_F(DataBaseTest, PayloadFile)
416 {
417 StoreObjPtr<EventMetaData> evtPtr;
418 DBObjPtr<PayloadFile> payload("file.xml");
419
420 evtPtr->setExperiment(1);
421 DBStore::Instance().update();
422 EXPECT_EQ(payload->getContent(), "Experiment 1\n") << payload->getFileName();
423 evtPtr->setExperiment(4);
424 DBStore::Instance().update();
425 EXPECT_EQ(payload->getContent(), "Experiment 4\n") << payload->getFileName();
426 evtPtr->setExperiment(7);
427 DBStore::Instance().update();
428 EXPECT_FALSE(payload);
429 }
430
432 int callbackCounter = 0;
433
434 void callback()
435 {
436 callbackCounter++;
437 }
438
439 class Callback {
440 public:
441 void callback()
442 {
443 callbackCounter++;
444 }
445 };
446 Callback callbackObject;
447
448 TEST_F(DataBaseTest, Callbacks)
449 {
450 StoreObjPtr<EventMetaData> evtPtr;
451 evtPtr->setRun(1);
452 evtPtr->setEvent(1);
453 callbackCounter = 0;
454
455 DBObjPtr<TNamed> named;
456 named.addCallback(&callback);
457 EXPECT_EQ(callbackCounter, 0);
458
459 evtPtr->setExperiment(2);
460 DBStore::Instance().update();
461 EXPECT_EQ(callbackCounter, 1);
462
463 evtPtr->setExperiment(4);
464 DBStore::Instance().update();
465 EXPECT_EQ(callbackCounter, 2);
466 DBStore::Instance().update();
467 EXPECT_EQ(callbackCounter, 2);
468
469 evtPtr->setExperiment(6);
470 DBStore::Instance().update();
471 EXPECT_EQ(callbackCounter, 3);
472
473 evtPtr->setExperiment(7);
474 DBStore::Instance().update();
475 EXPECT_EQ(callbackCounter, 3);
476
477 DBArray<TObject> objects;
478 objects.addCallback(&callback);
479
480 evtPtr->setExperiment(1);
481 DBStore::Instance().update();
482 // callbacks will now be called once for each payload so there is an extra call
483 EXPECT_EQ(callbackCounter, 5);
484
485 DBObjPtr<TNamed> intraRun("IntraRun");
486 intraRun.addCallback(&callbackObject, &Callback::callback);
487
488 //There won't be any callback here because the correct object is already set on creation
489 evtPtr->setEvent(1);
490 DBStore::Instance().updateEvent();
491 EXPECT_EQ(callbackCounter, 5);
492
493 evtPtr->setEvent(2);
494 DBStore::Instance().updateEvent();
495 EXPECT_EQ(callbackCounter, 5);
496
497 evtPtr->setEvent(10);
498 DBStore::Instance().updateEvent();
499 EXPECT_EQ(callbackCounter, 6);
500
501 evtPtr->setEvent(1);
502 DBStore::Instance().updateEvent();
503 EXPECT_EQ(callbackCounter, 7);
504 }
505
507 TEST_F(DataBaseTest, KeyAccess)
508 {
509 StoreObjPtr<EventMetaData> evtPtr;
510 evtPtr->setExperiment(1);
511 DBStore::Instance().update();
512
513 DBArray<TObject> objects;
514 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 1)->GetUniqueID(), 1);
515 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 2), nullptr);
516 EXPECT_EQ(objects.getByKey(&TObject::IsFolder, false)->GetUniqueID(), 1);
517 EXPECT_EQ(objects.getByKey(&TObject::IsFolder, true), nullptr);
518
519 evtPtr->setExperiment(2);
520 DBStore::Instance().update();
521
522 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 1)->GetUniqueID(), 1);
523 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 2)->GetUniqueID(), 2);
524 }
525
527 TEST_F(DataBaseTest, DBPointer)
528 {
529 StoreObjPtr<EventMetaData> evtPtr;
530 evtPtr->setExperiment(2);
531 DBStore::Instance().update();
532
533 DBPointer<TObject, unsigned int, &TObject::GetUniqueID> ptr(1);
534 EXPECT_EQ(ptr.key(), 1);
535 EXPECT_TRUE(ptr.isValid());
536 EXPECT_EQ(ptr->GetUniqueID(), 1);
537 ptr = 2;
538 EXPECT_EQ(ptr->GetUniqueID(), 2);
539 ptr = 3;
540 EXPECT_FALSE(ptr.isValid());
541 }
542
543 TEST_F(DataBaseTest, CleanupReattachDeathtest)
544 {
545 StoreObjPtr<EventMetaData> evtPtr;
546 evtPtr->setExperiment(2);
547 DBStore::Instance().update();
548
549 DBObjPtr<TNamed> named;
550 EXPECT_TRUE(named.isValid());
551 double Bz = BFieldManager::getField(0, 0, 0).Z() / Unit::T;
552 EXPECT_EQ(Bz, 1.5);
553 DBStore::Instance().reset();
554 //Ok, on next access the DBObjPtr should try to reconnect
555 EXPECT_TRUE(named.isValid());
556 //Which means the magnetic field should die a horrible death: It's not
557 //found in the database during testing, just a override.
558 EXPECT_B2FATAL(BFieldManager::getFieldInTesla({0, 0, 0}));
559 //Unless we add a new one
560 auto* field = new Belle2::MagneticField();
561 field->addComponent(new Belle2::MagneticFieldComponentConstant({0, 0, 1.5 * Belle2::Unit::T}));
562 Belle2::DBStore::Instance().addConstantOverride("MagneticField", field, false);
563 //So now it should work again
564 Bz = BFieldManager::getField(0, 0, 0).Z() / Unit::T;
565 EXPECT_EQ(Bz, 1.5);
566 }
567
570 class DataBaseNoDataStoreTest : public ::testing::Test {
571 protected:
572
574 enum EDatabaseType {c_local, c_central, c_chain, c_default};
575
577 EDatabaseType m_dbType = c_local;
578
579 TestHelpers::TempDirCreator m_tempDir;
581 EventMetaData m_event;
582
583 DataBaseNoDataStoreTest() : m_event(0, 0, 1) {};
584
586 void SetUp() override
587 {
588 auto& c = Conditions::Configuration::getInstance();
589 switch (m_dbType) {
590 case c_local:
591 c.setGlobalTags({});
592 c.overrideGlobalTags();
593 c.setMetadataProviders({});
594 c.setNewPayloadLocation("testPayloads/TestDatabase.txt");
595 c.appendTestingPayloadLocation("testPayloads/TestDatabase.txt");
596 break;
597 case c_central:
598 c.setGlobalTags({"default"});
599 c.overrideGlobalTags();
600 break;
601 case c_chain:
602 c.setGlobalTags({"default"});
603 c.overrideGlobalTags();
604 c.setMetadataProviders({});
605 c.setNewPayloadLocation("testPayloads/TestDatabase.txt");
606 c.appendTestingPayloadLocation("testPayloads/TestDatabase.txt");
607 break;
608 case c_default:
609 break;
610 }
611
612 if (m_dbType != c_central) {
613 list<Database::DBImportQuery> query;
614 TClonesArray array("TObject");
615 for (int experiment = 1; experiment <= 5; experiment++) {
616 IntervalOfValidity iov(experiment, -1, experiment, -1);
617
618 TString name = "Experiment ";
619 name += experiment;
620 query.push_back(Database::DBImportQuery("TNamed", new TNamed(name, name), iov));
621
622 new (array[experiment - 1]) TObject;
623 array[experiment - 1]->SetUniqueID(experiment);
624 Database::Instance().storeData("TObjects", &array, iov);
625
626 FILE* f = fopen("file.xml", "w");
627 fprintf(f, "Experiment %d\n", experiment);
628 fclose(f);
629 Database::Instance().addPayload("file.xml", "file.xml", iov);
630 }
631 if (m_dbType != c_chain) {
632 Database::Instance().storeData(query);
633 }
634
635 EventDependency intraRunDep(new TNamed("A", "A"));
636 intraRunDep.add(10, new TNamed("B", "B"));
637 intraRunDep.add(50, new TNamed("C", "C"));
638 IntervalOfValidity iov1(1, 1, 1, 1);
639 Database::Instance().storeData("IntraRun", &intraRunDep, iov1);
640 IntervalOfValidity iov2(1, 2, 1, -1);
641 Database::Instance().storeData("IntraRun", new TNamed("X", "X"), iov2);
642 }
643 }
644
646 void TearDown() override
647 {
648 if (m_dbType != c_central) std::filesystem::remove_all("testPayloads");
649 Database::reset();
650 }
651
652 };
653
655 TEST_F(DataBaseNoDataStoreTest, DBObjPtr)
656 {
657 DBStore::Instance().update(m_event); // The DBStore takes a reference to an EventMetaData object
658 DBObjPtr<TNamed> named;
659 m_event.setExperiment(1);
660 DBStore::Instance().update(m_event); // The DBStore takes a reference to an EventMetaData object
661 ASSERT_TRUE(named);
662 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 1") == 0);
663 m_event.setExperiment(4);
664 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 1") == 0);
665 DBStore::Instance().update(m_event);
666 EXPECT_TRUE(strcmp(named->GetName(), "Experiment 4") == 0);
667 m_event.setExperiment(7);
668 DBStore::Instance().update(m_event);
669 EXPECT_FALSE(named);
670 }
671
673 TEST_F(DataBaseNoDataStoreTest, DBArray)
674 {
675 DBStore::Instance().update(m_event);
676 DBArray<TObject> objects;
677 DBArray<TObject> missing("notexisting");
678 // check iteration on fresh object
679 {
680 int i = 0;
681 for (const auto& o : missing) {
682 (void)o;
683 ++i;
684 }
685 EXPECT_EQ(i, 0);
686 }
687
688
689 m_event.setExperiment(1);
690 DBStore::Instance().update(m_event);
691 EXPECT_TRUE(objects);
692 EXPECT_FALSE(missing);
693 EXPECT_EQ(objects.getEntries(), 1);
694 EXPECT_EQ(objects[0]->GetUniqueID(), 1);
695 m_event.setExperiment(4);
696 EXPECT_EQ(objects.getEntries(), 1);
697 DBStore::Instance().update(m_event);
698 EXPECT_EQ(objects.getEntries(), 4);
699 // check iteration on existing
700 {
701 int i = 0;
702 for (const auto& o : objects) {
703 EXPECT_EQ(o.GetUniqueID(), ++i);
704 }
705 EXPECT_EQ(i, 4);
706 }
707
708 // check iteration on missing object
709 {
710 int i = 0;
711 for (const auto& o : missing) {
712 (void)o;
713 ++i;
714 }
715 EXPECT_EQ(i, 0);
716 }
717 m_event.setExperiment(7);
718 DBStore::Instance().update(m_event);
719 EXPECT_FALSE(objects);
720 // check iteration over missing but previously existing
721 {
722 int i = 0;
723 for (const auto& o : objects) {
724 EXPECT_EQ(o.GetUniqueID(), ++i);
725 }
726 EXPECT_EQ(i, 0);
727 }
728 }
729
731 TEST_F(DataBaseNoDataStoreTest, DBArrayRange)
732 {
733 DBArray<TObject> objects;
734
735 m_event.setExperiment(3);
736 DBStore::Instance().update(m_event);
737 EXPECT_THROW(objects[-1], std::out_of_range);
738 EXPECT_THROW(objects[3], std::out_of_range);
739 }
740
742 TEST_F(DataBaseNoDataStoreTest, TypeCheck)
743 {
744 DBObjPtr<TNamed> named;
745 EXPECT_B2FATAL(DBObjPtr<EventMetaData> wrongType("TNamed"));
746
747 DBArray<TObject> objects;
748 EXPECT_B2FATAL(DBArray<EventMetaData> wrongType("TObjects"));
749 }
750
752 TEST_F(DataBaseNoDataStoreTest, IntraRun)
753 {
754 DBObjPtr<TNamed> intraRun("IntraRun");
755
756 m_event.setExperiment(1);
757 m_event.setRun(1);
758 m_event.setEvent(9);
759 DBStore::Instance().update(m_event);
760 DBStore::Instance().updateEvent(m_event.getEvent());
761 EXPECT_TRUE(strcmp(intraRun->GetName(), "A") == 0);
762
763 m_event.setEvent(10);
764 DBStore::Instance().updateEvent(m_event.getEvent());
765 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
766
767 m_event.setEvent(49);
768 DBStore::Instance().updateEvent(m_event.getEvent());
769 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
770
771 //let's run an update in between and make sure intra run continues to work
772 DBStore::Instance().update(m_event);
773 EXPECT_TRUE(strcmp(intraRun->GetName(), "B") == 0);
774
775 m_event.setEvent(50);
776 DBStore::Instance().updateEvent(m_event.getEvent());
777 EXPECT_TRUE(strcmp(intraRun->GetName(), "C") == 0);
778
779 m_event.setRun(2);
780 DBStore::Instance().update(m_event);
781 EXPECT_TRUE(strcmp(intraRun->GetName(), "X") == 0);
782 }
783
785 TEST_F(DataBaseNoDataStoreTest, HasChanged)
786 {
787 m_event.setExperiment(0);
788 DBStore::Instance().update(m_event);
789
790 DBObjPtr<TNamed> named;
791 EXPECT_FALSE(named.hasChanged());
792
793 m_event.setExperiment(1);
794 EXPECT_FALSE(named.hasChanged());
795
796 DBStore::Instance().update(m_event);
797 EXPECT_TRUE(named.hasChanged());
798
799 m_event.setRun(8);
800 DBStore::Instance().update(m_event);
801 EXPECT_FALSE(named.hasChanged());
802
803 m_event.setExperiment(5);
804 DBStore::Instance().update(m_event);
805 EXPECT_TRUE(named.hasChanged());
806
807 m_event.setExperiment(7);
808 DBStore::Instance().update(m_event);
809 EXPECT_TRUE(named.hasChanged());
810
811 m_event.setExperiment(1);
812 m_event.setRun(1);
813 m_event.setEvent(1);
814 DBObjPtr<TNamed> intraRun("IntraRun");
815 DBStore::Instance().update(m_event);
816 DBStore::Instance().updateEvent(m_event.getEvent());
817 EXPECT_TRUE(intraRun.hasChanged());
818
819 m_event.setEvent(2);
820 DBStore::Instance().updateEvent(m_event.getEvent());
821 EXPECT_FALSE(intraRun.hasChanged());
822
823 m_event.setEvent(10);
824 DBStore::Instance().updateEvent(m_event.getEvent());
825 EXPECT_TRUE(intraRun.hasChanged());
826
827 m_event.setEvent(1000);
828 DBStore::Instance().updateEvent(m_event.getEvent());
829 EXPECT_TRUE(intraRun.hasChanged());
830
831 m_event.setRun(4);
832 DBStore::Instance().update(m_event);
833 DBStore::Instance().updateEvent(m_event.getEvent());
834 EXPECT_TRUE(intraRun.hasChanged());
835 }
836
838 TEST_F(DataBaseNoDataStoreTest, PayloadFile)
839 {
840 DBStore::Instance().update(m_event);
841 DBObjPtr<PayloadFile> payload("file.xml");
842 m_event.setExperiment(1);
843 DBStore::Instance().update(m_event);
844 EXPECT_EQ(payload->getContent(), "Experiment 1\n") << payload->getFileName();
845 m_event.setExperiment(4);
846 DBStore::Instance().update(m_event);
847 EXPECT_EQ(payload->getContent(), "Experiment 4\n") << payload->getFileName();
848 m_event.setExperiment(7);
849 DBStore::Instance().update(m_event);
850 EXPECT_FALSE(payload);
851 }
852
855 TEST_F(DataBaseNoDataStoreTest, Callbacks)
856 {
857 m_event.setRun(1);
858 m_event.setEvent(1);
859 callbackCounter = 0;
860
861 DBObjPtr<TNamed> named;
862 named.addCallback(&callback);
863 EXPECT_EQ(callbackCounter, 0);
864
865 m_event.setExperiment(2);
866 DBStore::Instance().update(m_event);
867 EXPECT_EQ(callbackCounter, 1);
868
869 m_event.setExperiment(4);
870 DBStore::Instance().update(m_event);
871 EXPECT_EQ(callbackCounter, 2);
872 DBStore::Instance().update(m_event);
873 EXPECT_EQ(callbackCounter, 2);
874
875 m_event.setExperiment(6);
876 DBStore::Instance().update(m_event);
877 EXPECT_EQ(callbackCounter, 3);
878
879 m_event.setExperiment(7);
880 DBStore::Instance().update(m_event);
881 EXPECT_EQ(callbackCounter, 3);
882
883 DBArray<TObject> objects;
884 objects.addCallback(&callback);
885
886 m_event.setExperiment(1);
887 DBStore::Instance().update(m_event);
888 // callbacks will now be called once for each payload so there is an extra call
889 EXPECT_EQ(callbackCounter, 5);
890
891 DBObjPtr<TNamed> intraRun("IntraRun");
892 intraRun.addCallback(&callbackObject, &Callback::callback);
893
894 //There won't be any callback here because the correct object is already set on creation
895 m_event.setEvent(1);
896 DBStore::Instance().updateEvent(m_event.getEvent());
897 EXPECT_EQ(callbackCounter, 5);
898
899 m_event.setEvent(2);
900 DBStore::Instance().updateEvent(m_event.getEvent());
901 EXPECT_EQ(callbackCounter, 5);
902
903 m_event.setEvent(10);
904 DBStore::Instance().updateEvent(m_event.getEvent());
905 EXPECT_EQ(callbackCounter, 6);
906
907 m_event.setEvent(1);
908 DBStore::Instance().updateEvent(m_event.getEvent());
909 EXPECT_EQ(callbackCounter, 7);
910 }
911
913 TEST_F(DataBaseNoDataStoreTest, KeyAccess)
914 {
915 m_event.setExperiment(1);
916 DBStore::Instance().update(m_event);
917
918 DBArray<TObject> objects;
919 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 1)->GetUniqueID(), 1);
920 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 2), nullptr);
921 EXPECT_EQ(objects.getByKey(&TObject::IsFolder, false)->GetUniqueID(), 1);
922 EXPECT_EQ(objects.getByKey(&TObject::IsFolder, true), nullptr);
923
924 m_event.setExperiment(2);
925 DBStore::Instance().update(m_event);
926
927 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 1)->GetUniqueID(), 1);
928 EXPECT_EQ(objects.getByKey<unsigned int>(&TObject::GetUniqueID, 2)->GetUniqueID(), 2);
929 }
930
931 TEST_F(DataBaseNoDataStoreTest, DBPointer)
932 {
933 m_event.setExperiment(2);
934 DBStore::Instance().update(m_event);
935
936 DBPointer<TObject, unsigned int, &TObject::GetUniqueID> ptr(1);
937 EXPECT_EQ(ptr.key(), 1);
938 EXPECT_TRUE(ptr.isValid());
939 EXPECT_EQ(ptr->GetUniqueID(), 1);
940 ptr = 2;
941 EXPECT_EQ(ptr->GetUniqueID(), 2);
942 ptr = 3;
943 EXPECT_FALSE(ptr.isValid());
944 }
945} // namespace
Belle2::BFieldManager::getFieldInTesla
static ROOT::Math::XYZVector getFieldInTesla(const ROOT::Math::XYZVector &pos)
return the magnetic field at a given position in Tesla.
Definition: BFieldManager.h:61
Belle2::Conditions::Configuration::getInstance
static Configuration & getInstance()
Get a reference to the instance which will be used when the Database is initialized.
Belle2::DBAccessorBase::addCallback
void addCallback(std::function< void(const std::string &)> callback, bool onDestruction=false)
Add a callback method.
Definition: DBAccessorBase.h:105
Belle2::DBAccessorBase::isValid
bool isValid() const
Check whether a valid object was obtained from the database.
Definition: DBAccessorBase.h:72
Belle2::DBAccessorBase::hasChanged
bool hasChanged()
Check whether the object has changed since the last call to hasChanged of the accessor).
Definition: DBAccessorBase.h:89
Belle2::DBArray
Class for accessing arrays of objects in the database.
Definition: DBArray.h:26
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
Belle2::DBPointer
Class for pointing to an element in an array stored in the database.
Definition: DBPointer.h:24
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:54
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:94
Belle2::DataStore::reset
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
Definition: DataStore.cc:86
Belle2::Database::addPayload
bool addPayload(const std::string &name, const std::string &fileName, const IntervalOfValidity &iov)
Add a payload file to the database.
Definition: Database.h:192
Belle2::EventDependency
Class for handling changing conditions as a function of event number.
Definition: EventDependency.h:22
Belle2::EventMetaData
Store event, run, and experiment numbers.
Definition: EventMetaData.h:33
Belle2::EventMetaData::setEvent
void setEvent(unsigned int event)
Event Setter.
Definition: EventMetaData.h:55
Belle2::EventMetaData::setExperiment
void setExperiment(int experiment)
Experiment Setter.
Definition: EventMetaData.h:73
Belle2::EventMetaData::getEvent
unsigned int getEvent() const
Event Getter.
Definition: EventMetaData.h:145
Belle2::EventMetaData::setRun
void setRun(int run)
Run Setter.
Definition: EventMetaData.h:61
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:25
Belle2::IntervalOfValidity::trimOverlap
bool trimOverlap(IntervalOfValidity &iov, bool trimOlder=true)
Remove the overlap between two intervals of validity by shortening one of them.
Definition: IntervalOfValidity.cc:112
Belle2::IntervalOfValidity::empty
bool empty() const
Function that checks whether the validity interval is empty.
Definition: IntervalOfValidity.h:55
Belle2::MagneticFieldComponentConstant
Describe one component of the Geometry.
Definition: MagneticFieldComponentConstant.h:19
Belle2::MagneticField
Magnetic field map.
Definition: MagneticField.h:32
Belle2::PayloadFile
A wrapper class for payload files used by the Database and DBStore classes.
Definition: PayloadFile.h:23
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::construct
bool construct(Args &&... params)
Construct an object of type T in this StoreObjPtr, using the provided constructor arguments.
Definition: StoreObjPtr.h:119
Belle2::TestHelpers::TempDirCreator
changes working directory into a newly created directory, and removes it (and contents) on destructio...
Definition: TestHelpers.h:66
Belle2::Unit::T
static const double T
[tesla]
Definition: Unit.h:120
Belle2::DBStore::reset
void reset(bool keepEntries=false)
Invalidate all payloads.
Definition: DBStore.cc:177
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:42
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:28
Belle2::Database::storeData
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition: Database.cc:141
Belle2::DBStore::updateEvent
void updateEvent()
Updates all intra-run dependent objects.
Definition: DBStore.cc:142
Belle2::DBStore::update
void update()
Updates all objects that are outside their interval of validity.
Definition: DBStore.cc:79
Belle2::DBStore::addConstantOverride
void addConstantOverride(const std::string &name, TObject *obj, bool oneRun=false)
Add constant override payload.
Definition: DBStore.cc:204
Belle2::BFieldManager::getField
static void getField(const double *pos, double *field)
return the magnetic field at a given position.
Definition: BFieldManager.h:91
Belle2::Database::reset
static void reset(bool keepConfig=false)
Reset the database instance.
Definition: Database.cc:50
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::Database::DBImportQuery
Struct for bulk write queries.
Definition: Database.h:77