From fbcf94d1c2befa6b7cab9053cc8c5767ae3c4395 Mon Sep 17 00:00:00 2001 From: blue Date: Sun, 15 Oct 2023 11:10:27 -0300 Subject: [PATCH] Doc fixes, testing for QVariant --- CHANGELOG.md | 8 ++-- src/storage.hpp | 8 ++-- test/basic.cpp | 109 ++++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 114 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 035262c..1cd74a2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,9 +1,12 @@ # Changelog -## LMDBAL 0.5.0 (UNRELEASED, 2023) +## LMDBAL 0.5.0 (October 15, 2023) ### New Features -- duplicates support +- duplicates support (only for table) +### Improvements +- some more documentation +- more tests ## LMDBAL 0.4.0 (August 13, 2023) ### New Features @@ -17,7 +20,6 @@ - some more documentation - more tests - ## LMDBAL 0.3.1 (April 14, 2023) ### Bug fixes - build with qt5 now is possible again diff --git a/src/storage.hpp b/src/storage.hpp index b3ef621..8c52bf6 100644 --- a/src/storage.hpp +++ b/src/storage.hpp @@ -321,7 +321,7 @@ void LMDBAL::Storage::changeRecord(const K& key, const V& value, Transacti * If the storage supports duplicates the exact value returned from it depends on comparison function of lmdb. * It's not very straight forward, so, you shouldn't really use this method if you use duplicates and you rely on exact result. * Anyway: - * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. + * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. * - if your values are anything else - they are compared byte by byte as if they are strings, it makes it especially complicated to predict the exact value for float or double templated storages. For strings if makes a bit more sence: if the choise is from "50" and "100" - "100" is returned, because the first byte of the "100" is lower than the first byte of the "50" * * \param[in] key key of the record you look for @@ -348,7 +348,7 @@ V LMDBAL::Storage::getRecord(const K& key) const { * If the storage supports duplicates the exact value returned from it depends on comparison function of lmdb. * It's not very straight forward, so, you shouldn't really use this method if you use duplicates and you rely on exact result. * Anyway: - * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. + * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. * - if your values are anything else - they are compared byte by byte as if they are strings, it makes it especially complicated to predict the exact value for float or double templated storages. For strings if makes a bit more sence: if the choise is from "50" and "100" - "100" is returned, because the first byte of the "100" is lower than the first byte of the "50" * * \param[in] key key of the record you look for @@ -384,7 +384,7 @@ void LMDBAL::Storage::getRecord(const K& key, V& value) const { * If the storage supports duplicates the exact value returned from it depends on comparison function of lmdb. * It's not very straight forward, so, you shouldn't really use this method if you use duplicates and you rely on exact result. * Anyway: - * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. + * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. * - if your values are anything else - they are compared byte by byte as if they are strings, it makes it especially complicated to predict the exact value for float or double templated storages. For strings if makes a bit more sence: if the choise is from "50" and "100" - "100" is returned, because the first byte of the "100" is lower than the first byte of the "50" * * \param[in] key key of the record you look for @@ -415,7 +415,7 @@ V LMDBAL::Storage::getRecord(const K& key, TransactionID txn) const { * If the storage supports duplicates the exact value returned from it depends on comparison function of lmdb. * It's not very straight forward, so, you shouldn't really use this method if you use duplicates and you rely on exact result. * Anyway: - * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. + * - if your values are signed or unsigned integer of any size the LOWEST value is returned compared as UNSIGNED. For example for storage with int32_t as value, from the same key, from the set of values {-33, -1, 5573, 77753} 5573 is returned as it is the lowest by UNSIGNED comparison. * - if your values are anything else - they are compared byte by byte as if they are strings, it makes it especially complicated to predict the exact value for float or double templated storages. For strings if makes a bit more sence: if the choise is from "50" and "100" - "100" is returned, because the first byte of the "100" is lower than the first byte of the "50" * * \param[in] key key of the record you look for diff --git a/test/basic.cpp b/test/basic.cpp index 460ce36..559993d 100644 --- a/test/basic.cpp +++ b/test/basic.cpp @@ -12,13 +12,15 @@ protected: ::testing::Test(), t1(db->getStorage("table1")), t2(db->getStorage("table2")), - c1(db->getCache("cache1")) {} + c1(db->getCache("cache1")), + c2(db->getCache("cache2")) {} ~BaseTest() {} uint32_t getT1Flags() const {return t1->flags();} uint32_t getT2Flags() const {return t2->flags();} uint32_t getC1Flags() const {return c1->flags();} + uint32_t getC2Flags() const {return c2->flags();} static void SetUpTestSuite() { if (db == nullptr) { @@ -26,6 +28,7 @@ protected: db->addStorage("table1"); db->addStorage("table2"); db->addCache("cache1"); + db->addCache("cache2"); } } @@ -41,6 +44,7 @@ protected: LMDBAL::Storage* t1; LMDBAL::Storage* t2; LMDBAL::Cache* c1; + LMDBAL::Cache* c2; }; @@ -64,6 +68,7 @@ TEST_F(BaseTest, Flags) { uint32_t t1Flags = getT1Flags(); uint32_t t2Flags = getT2Flags(); uint32_t c1Flags = getC1Flags(); + uint32_t c2Flags = getC2Flags(); EXPECT_TRUE(t1Flags & MDB_INTEGERKEY); EXPECT_FALSE(t1Flags & MDB_DUPSORT); @@ -79,6 +84,11 @@ TEST_F(BaseTest, Flags) { EXPECT_FALSE(c1Flags & MDB_DUPSORT); EXPECT_FALSE(c1Flags & MDB_DUPFIXED); EXPECT_FALSE(c1Flags & MDB_INTEGERDUP); + + EXPECT_FALSE(c2Flags & MDB_INTEGERKEY); + EXPECT_FALSE(c2Flags & MDB_DUPSORT); + EXPECT_FALSE(c2Flags & MDB_DUPFIXED); + EXPECT_FALSE(c2Flags & MDB_INTEGERDUP); } TEST_F(BaseTest, AddingIntegerKey) { @@ -108,6 +118,19 @@ TEST_F(BaseTest, AddingKeysToCache) { EXPECT_EQ(c1->getRecord(-116), "whatever"); } +TEST_F(BaseTest, AddingKeysToVariableCache) { + EXPECT_EQ(db->ready(), true); + c2->addRecord("regrets", "blah balah"); + c2->addRecord("fossil fingers", 842); + c2->addRecord("preloaded cut", 539.75); + c2->addRecord("dihotomy", false); + + EXPECT_EQ(c2->getRecord("regrets"), "blah balah"); + EXPECT_EQ(c2->getRecord("fossil fingers"), 842); + EXPECT_EQ(c2->getRecord("preloaded cut"), 539.75); + EXPECT_EQ(c2->getRecord("dihotomy"), false); +} + TEST_F(BaseTest, AddingRepeatingKey) { EXPECT_EQ(db->ready(), true); @@ -119,6 +142,9 @@ TEST_F(BaseTest, AddingRepeatingKey) { EXPECT_THROW(c1->addRecord(-4, "world"), LMDBAL::Exist); EXPECT_EQ(c1->getRecord(-4), "testing goes brrr"); + + EXPECT_THROW(c2->addRecord("dihotomy", "pired"), LMDBAL::Exist); + EXPECT_EQ(c2->getRecord("dihotomy"), false); } TEST_F(BaseTest, GettingNotExistingKeys) { @@ -127,6 +153,7 @@ TEST_F(BaseTest, GettingNotExistingKeys) { EXPECT_THROW(t2->getRecord("almonds"), LMDBAL::NotFound); EXPECT_THROW(t1->getRecord(64), LMDBAL::NotFound); EXPECT_THROW(c1->getRecord(21), LMDBAL::NotFound); + EXPECT_THROW(c2->getRecord("praising"), LMDBAL::NotFound); } TEST_F(BaseTest, Persistence) { @@ -134,6 +161,7 @@ TEST_F(BaseTest, Persistence) { uint32_t t1Size = t1->count(); uint32_t t2Size = t2->count(); uint32_t c1Size = c1->count(); + uint32_t c2Size = c2->count(); db->close(); delete db; @@ -142,6 +170,7 @@ TEST_F(BaseTest, Persistence) { t1 = db->addStorage("table1"); t2 = db->addStorage("table2"); c1 = db->addCache("cache1"); + c2 = db->addCache("cache2"); db->open(); EXPECT_EQ(t1->count(), t1Size); @@ -170,9 +199,16 @@ TEST_F(BaseTest, Persistence) { EXPECT_EQ(c1->getRecord(2), "blah balah"); EXPECT_EQ(c1->count(), c1Size); + EXPECT_EQ(c2->count(), c2Size); + EXPECT_EQ(c2->getRecord("regrets"), "blah balah"); + EXPECT_EQ(c2->getRecord("fossil fingers"), 842); + EXPECT_EQ(c2->getRecord("preloaded cut"), 539.75); + EXPECT_EQ(c2->getRecord("dihotomy"), false); + EXPECT_THROW(t2->getRecord("cats"), LMDBAL::NotFound); EXPECT_THROW(t1->getRecord(7893), LMDBAL::NotFound); EXPECT_THROW(c1->getRecord(89), LMDBAL::NotFound); + EXPECT_THROW(c2->getRecord("marathons"), LMDBAL::NotFound); } TEST_F(BaseTest, CountAndDrop) { @@ -180,21 +216,24 @@ TEST_F(BaseTest, CountAndDrop) { EXPECT_EQ(t1->count(), 3); EXPECT_EQ(t2->count(), 4); EXPECT_EQ(c1->count(), 4); - + EXPECT_EQ(c2->count(), 4); db->drop(); EXPECT_EQ(t1->count(), 0); EXPECT_EQ(t2->count(), 0); EXPECT_EQ(c1->count(), 0); + EXPECT_EQ(c2->count(), 0); t1->addRecord(2, 2); t2->addRecord("sdfhga", "world"); c1->addRecord(15, "world"); c1->addRecord(12, "grr grr"); + c2->addRecord("blues", -749); EXPECT_EQ(t1->count(), 1); EXPECT_EQ(t2->count(), 1); EXPECT_EQ(c1->count(), 2); + EXPECT_EQ(c2->count(), 1); } TEST_F(BaseTest, Change) { @@ -202,37 +241,45 @@ TEST_F(BaseTest, Change) { EXPECT_EQ(t1->count(), 1); EXPECT_EQ(t2->count(), 1); EXPECT_EQ(c1->count(), 2); + EXPECT_EQ(c2->count(), 1); EXPECT_EQ(t1->getRecord(2), 2); EXPECT_EQ(t2->getRecord("sdfhga"), "world"); EXPECT_EQ(c1->getRecord(15), "world"); EXPECT_EQ(c1->getRecord(12), "grr grr"); + EXPECT_EQ(c2->getRecord("blues"), -749); t1->addRecord(58, 39); t2->addRecord("lawfirm", "stumble"); c1->addRecord(89, "answer"); + c2->addRecord("wielders", QStringList({"calcium", "eagles"})); t1->changeRecord(2, 49); t2->changeRecord("sdfhga", "void"); c1->changeRecord(15, "recording"); c1->changeRecord(12, "thermal"); + c2->changeRecord("blues", true); EXPECT_THROW(t1->changeRecord(37, 49), LMDBAL::NotFound); EXPECT_THROW(t2->changeRecord("precision", "cryoplastics"), LMDBAL::NotFound); EXPECT_THROW(c1->changeRecord(-62, "sharks"), LMDBAL::NotFound); + EXPECT_THROW(c2->changeRecord("visions", 90), LMDBAL::NotFound); EXPECT_EQ(t1->getRecord(2), 49); EXPECT_EQ(t2->getRecord("sdfhga"), "void"); EXPECT_EQ(c1->getRecord(15), "recording"); EXPECT_EQ(c1->getRecord(12), "thermal"); + EXPECT_EQ(c2->getRecord("blues"), true); EXPECT_EQ(t1->getRecord(58), 39); EXPECT_EQ(t2->getRecord("lawfirm"), "stumble"); EXPECT_EQ(c1->getRecord(89), "answer"); + EXPECT_EQ(c2->getRecord("wielders"), QStringList({"calcium", "eagles"})); EXPECT_EQ(t1->count(), 2); EXPECT_EQ(t2->count(), 2); EXPECT_EQ(c1->count(), 3); + EXPECT_EQ(c2->count(), 2); } TEST_F(BaseTest, Force) { @@ -244,21 +291,30 @@ TEST_F(BaseTest, Force) { EXPECT_EQ(t2->forceRecord("lawfirm", "paracetamol"), false); //changing EXPECT_EQ(c1->forceRecord(89, "canine"), false); //changing EXPECT_EQ(c1->forceRecord(98, "duration"), true); //adding + EXPECT_EQ(c2->forceRecord("wielders", "charm"), false); //changing + EXPECT_EQ(c2->forceRecord("tedious", 5732.89), true); //adding EXPECT_EQ(t1->getRecord(2), 49); EXPECT_EQ(t1->getRecord(58), 35); EXPECT_EQ(t1->getRecord(68), 36); + EXPECT_EQ(t2->getRecord("sdfhga"), "void"); EXPECT_EQ(t2->getRecord("prophecy"), "dumpling"); EXPECT_EQ(t2->getRecord("lawfirm"), "paracetamol"); + EXPECT_EQ(c1->getRecord(15), "recording"); EXPECT_EQ(c1->getRecord(12), "thermal"); EXPECT_EQ(c1->getRecord(89), "canine"); EXPECT_EQ(c1->getRecord(98), "duration"); + EXPECT_EQ(c2->getRecord("blues"), true); + EXPECT_EQ(c2->getRecord("tedious"), 5732.89); + EXPECT_EQ(c2->getRecord("wielders"), "charm"); + EXPECT_EQ(t1->count(), 3); EXPECT_EQ(t2->count(), 3); EXPECT_EQ(c1->count(), 4); + EXPECT_EQ(c2->count(), 3); } TEST_F(BaseTest, ReadAll) { @@ -267,21 +323,29 @@ TEST_F(BaseTest, ReadAll) { std::map m1 = t1->readAll(); std::map m2 = t2->readAll(); std::map m3 = c1->readAll(); + std::map m4 = c2->readAll(); EXPECT_EQ(m1.at(2), 49); EXPECT_EQ(m1.at(58), 35); EXPECT_EQ(m1.at(68), 36); + EXPECT_EQ(m2.at("sdfhga"), "void"); EXPECT_EQ(m2.at("prophecy"), "dumpling"); EXPECT_EQ(m2.at("lawfirm"), "paracetamol"); + EXPECT_EQ(m3.at(15), "recording"); EXPECT_EQ(m3.at(12), "thermal"); EXPECT_EQ(m3.at(89), "canine"); EXPECT_EQ(m3.at(98), "duration"); + EXPECT_EQ(m4.at("blues"), true); + EXPECT_EQ(m4.at("tedious"), 5732.89); + EXPECT_EQ(m4.at("wielders"), "charm"); + EXPECT_EQ(m1.size(), 3); EXPECT_EQ(m2.size(), 3); EXPECT_EQ(m3.size(), 4); + EXPECT_EQ(m4.size(), 3); } TEST_F(BaseTest, ReplaceAll) { @@ -299,10 +363,14 @@ TEST_F(BaseTest, ReplaceAll) { {"ronin", "cheese"} }); c1->replaceAll({}); + c2->replaceAll({ + {"kind", 73} + }); EXPECT_EQ(t1->count(), 4); EXPECT_EQ(t2->count(), 3); EXPECT_EQ(c1->count(), 0); + EXPECT_EQ(c2->count(), 1); EXPECT_FALSE(t1->checkRecord(2)); EXPECT_FALSE(t1->checkRecord(58)); @@ -317,6 +385,10 @@ TEST_F(BaseTest, ReplaceAll) { EXPECT_FALSE(c1->checkRecord(89)); EXPECT_FALSE(c1->checkRecord(98)); + EXPECT_FALSE(c2->checkRecord("blues")); + EXPECT_FALSE(c2->checkRecord("tedious")); + EXPECT_FALSE(c2->checkRecord("wielders")); + EXPECT_EQ(t1->getRecord(7), 48); EXPECT_EQ(t1->getRecord(194), 582); EXPECT_EQ(t1->getRecord(857), 39); @@ -326,6 +398,8 @@ TEST_F(BaseTest, ReplaceAll) { EXPECT_EQ(t2->getRecord("cluster"), "throttle"); EXPECT_EQ(t2->getRecord("ronin"), "cheese"); + EXPECT_EQ(c2->getRecord("kind"), 73); + c1->replaceAll({ {68, "quality"}, {31, "ridgid body"}, @@ -342,8 +416,6 @@ TEST_F(BaseTest, ReplaceAll) { EXPECT_EQ(c1->getRecord(-117), "lance of Michael"); } - - TEST_F(BaseTest, AddRecords) { EXPECT_EQ(db->ready(), true); @@ -472,4 +544,33 @@ TEST_F(BaseTest, AddRecords) { EXPECT_EQ(c1->getRecord(-32), "stitched"); EXPECT_EQ(c1->getRecord(123), "horibly unforseen"); + LMDBAL::SizeType s4 = c2->addRecords({ + {"and wholesome", "preaching"}, + {"ginger", false} + }); + + EXPECT_EQ(c2->count(), 3); + EXPECT_EQ(s4, 3); + + EXPECT_THROW( + s4 = c2->addRecords({ + {"returning favor", 'c'}, + {"ginger", 23}, + {"frames", true} + }), LMDBAL::Exist + ); + EXPECT_EQ(c2->count(), 3); + + s4 = c2->addRecords({ + {"and wholesome", -1}, + {"orcid", 89.9} + }, true); + + EXPECT_EQ(c2->count(), 4); + EXPECT_EQ(s4, 4); + + EXPECT_EQ(c2->getRecord("and wholesome"), -1); + EXPECT_EQ(c2->getRecord("orcid"), 89.9); + EXPECT_EQ(c2->getRecord("ginger"), false); + EXPECT_EQ(c2->getRecord("kind"), 73); }