dbzero 0.6.0__tar.gz → 0.6.1__tar.gz

{dbzero-0.6.0 → dbzero-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.6.0
+Version: 0.6.1
 Summary: A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.
 Author-Email: "DBZero Software sp. z o.o" <info@dbzero.io>
 License:                   GNU LESSER GENERAL PUBLIC LICENSE

{dbzero-0.6.0 → dbzero-0.6.1}/dbzero/setup.py

@@ -10,7 +10,7 @@ if sys.byteorder == 'big':
 
 setup(
     name='dbzero',
-    version='0.6.0',
+    version='0.6.1',
     description='DBZero community edition',
     packages=['dbzero'],
     python_requires='>=3.9',

{dbzero-0.6.0 → dbzero-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ['meson-python']
 
 [project]
 name = 'dbzero'
-version = '0.6.0'
+version = '0.6.1'
 description = 'A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.'
 readme = 'README.md'
 requires-python = '>=3.9'

{dbzero-0.6.0 → dbzero-0.6.1}/python_tests/test_index.py

@@ -87,6 +87,17 @@ def test_index_can_store_nulls(db0_fixture):
     assert values == [2, 0, 3, 4, 1]
 
 
+def test_find_with_negated_tag_and_empty_subquery_returns_empty(db0_fixture):
+    index = db0.index()
+    contact = MemoTestClass("not-overdue")
+    index.add(datetime(2026, 1, 2), contact)
+
+    overdue_contacts = db0.find(MemoTestClass, index.select(None, datetime(2026, 1, 1)))
+    assert not overdue_contacts
+
+    assert list(db0.find(MemoTestClass, db0.no("archived"), overdue_contacts)) == []
+
+
 def test_index_can_sort_by_multiple_criteria(db0_fixture):
     index_1 = db0.index()
     index_2 = db0.index()

{dbzero-0.6.0 → dbzero-0.6.1}/python_tests/test_tag_fields.py

@@ -434,6 +434,73 @@ def test_non_tag_fields_and_manual_passive_tags_are_unchanged(db0_fixture):
     assert list(db0.find(MixedRuntimeFields, "manual")) == [obj]
 
 
+def test_passive_tag_field_then_regular_foreign_tag_preserves_regular_target(db0_fixture):
+    @db0.memo
+    class Scope:
+        pass
+
+    @db0.memo
+    @db0.tag_fields("scope")
+    class PassiveRecord:
+        def __init__(self, scope):
+            self.scope = scope
+
+    @db0.memo
+    class Error:
+        pass
+
+    def add_error(scope):
+        error = Error()
+        db0.tags(error).add(db0.as_tag(scope))
+
+    scope = Scope()
+
+    PassiveRecord(scope)
+    add_error(scope)
+
+    assert len(list(db0.find(Error, db0.as_tag(scope)))) == 1
+
+
+def test_mixed_passive_regular_foreign_tag_remove_releases_regular_target(db0_fixture):
+    @db0.memo
+    class Scope:
+        pass
+
+    @db0.memo
+    @db0.tag_fields("scope")
+    class PassiveRecord:
+        def __init__(self, scope):
+            self.scope = scope
+
+    @db0.memo
+    class RegularTarget:
+        def __init__(self):
+            pass
+
+    scope = Scope()
+    tag = db0.as_tag(scope)
+    PassiveRecord(scope)
+
+    target = RegularTarget()
+    target_uuid = db0.uuid(target)
+    db0.tags(target).add(tag)
+    db0.commit()
+
+    assert list(db0.find(RegularTarget, tag)) == [target]
+    assert db0.getrefcount(target) == 1
+
+    db0.tags(target).remove(tag)
+    db0.commit()
+
+    assert list(db0.find(RegularTarget, tag)) == []
+    assert db0.getrefcount(target) == 0
+
+    del target
+    db0.commit()
+
+    assert not db0.exists(target_uuid)
+
+
 def test_tag_field_removal_preserves_manual_collision_semantics(db0_fixture):
     @db0.memo
     @db0.tag_fields("status")

{dbzero-0.6.0 → dbzero-0.6.1}/python_tests/test_tags.py

@@ -124,22 +124,41 @@ def test_passive_tags_can_be_added_and_removed_from_find_results(db0_fixture):
     assert {item.value for item in db0.find("other")} == {3}
 
 
-def test_passive_first_then_regular_tag_remains_non_durable(db0_fixture):
+def test_passive_first_then_regular_tag_upgrades_to_durable(db0_fixture):
     object_1 = MemoNoDefTags(1)
     db0.tags(object_1, passive=True).add("passive-tag")
     db0.commit()
     db0.tags(object_1).add("passive-tag")
     db0.commit()
-    assert db0.getrefcount(object_1) == 0
+    assert db0.getrefcount(object_1) == 1
 
 
-def test_passive_first_then_regular_tag_in_same_transaction_remains_non_durable(db0_fixture):
+def test_passive_first_then_regular_tag_in_same_transaction_upgrades_to_durable(db0_fixture):
     object_1 = MemoNoDefTags(1)
     db0.tags(object_1, passive=True).add("passive-tag")
     db0.tags(object_1).add("passive-tag")
     db0.commit()
+    assert db0.getrefcount(object_1) == 1
+
+
+def test_passive_first_then_regular_tag_remove_releases_upgrade(db0_fixture):
+    object_1 = MemoNoDefTags(1)
+    object_uuid = db0.uuid(object_1)
+
+    db0.tags(object_1, passive=True).add("passive-tag")
+    db0.commit()
+    db0.tags(object_1).add("passive-tag")
+    db0.commit()
+    assert db0.getrefcount(object_1) == 1
+
+    db0.tags(object_1).remove("passive-tag")
+    db0.commit()
     assert db0.getrefcount(object_1) == 0
 
+    del object_1
+    db0.commit()
+    assert not db0.exists(object_uuid)
+
 
 def test_regular_first_then_passive_tag_remains_durable(db0_fixture):
     object_1 = MemoNoDefTags(1)
@@ -224,7 +243,7 @@ def test_passive_foreign_tag_remove_uses_regular_remove(db0_fixture):
     assert list(db0.find(MemoClassForTags, foreign_tag)) == []
 
 
-def test_passive_foreign_tag_first_then_regular_remains_non_durable(db0_fixture):
+def test_passive_foreign_tag_first_then_regular_upgrades_to_durable(db0_fixture):
     foreign_tag_source = MemoScopedClass(2)
     foreign_tag = db0.as_tag(foreign_tag_source)
     db0.open("passive-long-tag-prefix", "rw")
@@ -235,6 +254,29 @@ def test_passive_foreign_tag_first_then_regular_remains_non_durable(db0_fixture)
     db0.commit()
     db0.tags(local_object).add(foreign_tag)
     db0.commit()
+    assert db0.getrefcount(local_object) == 1
+
+    del local_object
+    db0.commit()
+    assert db0.exists(local_uuid)
+    assert [item.value for item in db0.find(MemoNoDefTags, foreign_tag)] == [1]
+
+
+def test_passive_foreign_tag_first_then_regular_remove_releases_upgrade(db0_fixture):
+    foreign_tag_source = MemoScopedClass(2)
+    foreign_tag = db0.as_tag(foreign_tag_source)
+    db0.open("passive-long-tag-prefix", "rw")
+    local_object = MemoNoDefTags(1)
+    local_uuid = db0.uuid(local_object)
+
+    db0.tags(local_object, passive=True).add(foreign_tag)
+    db0.commit()
+    db0.tags(local_object).add(foreign_tag)
+    db0.commit()
+    assert db0.getrefcount(local_object) == 1
+
+    db0.tags(local_object).remove(foreign_tag)
+    db0.commit()
     assert db0.getrefcount(local_object) == 0
 
     del local_object

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/bindings/python/collections/meson.build

@@ -1,12 +1,12 @@
 
 all_srcs += [
-meson.current_source_dir() / 'PyIndex.cpp',
+meson.current_source_dir() / 'PyByteArray.cpp',
+meson.current_source_dir() / 'PyWeakSet.cpp',
 meson.current_source_dir() / 'PyDict.cpp',
-meson.current_source_dir() / 'PySet.cpp',
+meson.current_source_dir() / 'PyIndex.cpp',
 meson.current_source_dir() / 'PyDictView.cpp',
-meson.current_source_dir() / 'PyByteArray.cpp',
-meson.current_source_dir() / 'PyTuple.cpp',
 meson.current_source_dir() / 'PyList.cpp',
-meson.current_source_dir() / 'PyWeakSet.cpp']
+meson.current_source_dir() / 'PySet.cpp',
+meson.current_source_dir() / 'PyTuple.cpp']
 
         

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/bindings/python/embedded/meson.build

@@ -1,8 +1,8 @@
 
 all_srcs += [
-meson.current_source_dir() / 'EmbeddedSet.cpp',
-meson.current_source_dir() / 'EmbeddedDict.cpp',
 meson.current_source_dir() / 'EmbeddedObject.cpp',
-meson.current_source_dir() / 'EmbeddedTuple.cpp']
+meson.current_source_dir() / 'EmbeddedTuple.cpp',
+meson.current_source_dir() / 'EmbeddedSet.cpp',
+meson.current_source_dir() / 'EmbeddedDict.cpp']
 
         

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/bindings/python/iter/meson.build

@@ -1,8 +1,8 @@
 
 all_srcs += [
-meson.current_source_dir() / 'PyJoinIterator.cpp',
-meson.current_source_dir() / 'PyJoinIterable.cpp',
 meson.current_source_dir() / 'PyObjectIterable.cpp',
-meson.current_source_dir() / 'PyObjectIterator.cpp']
+meson.current_source_dir() / 'PyObjectIterator.cpp',
+meson.current_source_dir() / 'PyJoinIterator.cpp',
+meson.current_source_dir() / 'PyJoinIterable.cpp']
 
         

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/bindings/python/meson.build

@@ -1,35 +1,35 @@
 subdir('types')
+subdir('collections')
 subdir('embedded')
 subdir('iter')
-subdir('collections')
 
 all_srcs += [
 meson.current_source_dir() / 'WhichType.cpp',
-meson.current_source_dir() / 'PyReflectionAPI.cpp',
-meson.current_source_dir() / 'PyTagSet.cpp',
+meson.current_source_dir() / 'PySafeAPI.cpp',
+meson.current_source_dir() / 'PyAPI.cpp',
+meson.current_source_dir() / 'PyFieldRef.cpp',
+meson.current_source_dir() / 'PyInternalAPI.cpp',
 meson.current_source_dir() / 'PySnapshot.cpp',
-meson.current_source_dir() / 'ArgParse.cpp',
-meson.current_source_dir() / 'Migration.cpp',
-meson.current_source_dir() / 'shared_py_object.cpp',
-meson.current_source_dir() / 'PyHash.cpp',
-meson.current_source_dir() / 'Memo.cpp',
-meson.current_source_dir() / 'MemoTypeDecoration.cpp',
-meson.current_source_dir() / 'MemoExpiredRef.cpp',
 meson.current_source_dir() / 'PyLocked.cpp',
+meson.current_source_dir() / 'MemoTypeDecoration.cpp',
+meson.current_source_dir() / 'PyWorkspace.cpp',
 meson.current_source_dir() / 'PyTagsAPI.cpp',
-meson.current_source_dir() / 'PyInternalAPI.cpp',
-meson.current_source_dir() / 'PyTypeManager.cpp',
-meson.current_source_dir() / 'PyRestrictedMethod.cpp',
-meson.current_source_dir() / 'PyWeakProxy.cpp',
 meson.current_source_dir() / 'PyAtomic.cpp',
-meson.current_source_dir() / 'PyObjectTagManager.cpp',
-meson.current_source_dir() / 'PySafeAPI.cpp',
-meson.current_source_dir() / 'PyLocks.cpp',
 meson.current_source_dir() / 'dbzero.cpp',
-meson.current_source_dir() / 'PyWorkspace.cpp',
+meson.current_source_dir() / 'PyReflectionAPI.cpp',
+meson.current_source_dir() / 'PyHash.cpp',
+meson.current_source_dir() / 'Memo.cpp',
 meson.current_source_dir() / 'Types.cpp',
-meson.current_source_dir() / 'PyFieldRef.cpp',
-meson.current_source_dir() / 'PyAPI.cpp',
-meson.current_source_dir() / 'PyToolkit.cpp']
+meson.current_source_dir() / 'MemoExpiredRef.cpp',
+meson.current_source_dir() / 'PyWeakProxy.cpp',
+meson.current_source_dir() / 'ArgParse.cpp',
+meson.current_source_dir() / 'PyToolkit.cpp',
+meson.current_source_dir() / 'PyRestrictedMethod.cpp',
+meson.current_source_dir() / 'PyLocks.cpp',
+meson.current_source_dir() / 'PyTypeManager.cpp',
+meson.current_source_dir() / 'PyTagSet.cpp',
+meson.current_source_dir() / 'PyObjectTagManager.cpp',
+meson.current_source_dir() / 'shared_py_object.cpp',
+meson.current_source_dir() / 'Migration.cpp']
 
         

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/bindings/python/types/meson.build

@@ -1,13 +1,13 @@
 
 all_srcs += [
-meson.current_source_dir() / 'PyObjectId.cpp',
-meson.current_source_dir() / 'PyEnum.cpp',
-meson.current_source_dir() / 'DateTime.cpp',
 meson.current_source_dir() / 'PyClass.cpp',
-meson.current_source_dir() / 'PyClassFields.cpp',
+meson.current_source_dir() / 'PyEnum.cpp',
 meson.current_source_dir() / 'ByteUtils.cpp',
-meson.current_source_dir() / 'PyTag.cpp',
+meson.current_source_dir() / 'PyObjectId.cpp',
+meson.current_source_dir() / 'PyEnumType.cpp',
 meson.current_source_dir() / 'PyDecimal.cpp',
-meson.current_source_dir() / 'PyEnumType.cpp']
+meson.current_source_dir() / 'DateTime.cpp',
+meson.current_source_dir() / 'PyTag.cpp',
+meson.current_source_dir() / 'PyClassFields.cpp']
 
         

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/core/collections/b_index/bindex_interface.hpp

@@ -28,6 +28,17 @@ namespace db0::bindex::interface
     using bulkInsertUniquePtr = std::pair<std::uint32_t, std::uint32_t>(*)
         (void *this_ptr, typename DefinitionT::Containers::IInputRange&, std::function<void(typename DefinitionT::item_t)> *callback_ptr);
 
+    /**
+     * Heteromorphic inserts are for item types whose comparator/equality identity can match even
+     * when the stored bit pattern differs. On such duplicates, resolver_ptr decides whether the
+     * incoming representation should replace the stored one.
+     */
+    template<typename DefinitionT>
+    using bulkInsertUniqueHeteromorphicPtr = std::pair<std::uint32_t, std::uint32_t>(*)
+        (void *this_ptr, typename DefinitionT::Containers::IInputRange&,
+            std::function<void(typename DefinitionT::item_t)> *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr);
+
     template <typename item_t> using insertPtr = void (*)(void *this_ptr, const item_t &item);
     
     template<typename DefinitionT>
@@ -97,6 +108,8 @@ namespace db0::bindex::interface
 
     template <typename DefinitionT, typename T> struct BulkInsertUniqueFunctor {};
 
+    template <typename DefinitionT, typename T> struct BulkInsertUniqueHeteromorphicFunctor {};
+
     template <typename item_t, typename T> struct InsertFunctor {};
 
     template <typename DefinitionT, typename T> struct BulkEraseFunctor {};
@@ -139,6 +152,17 @@ namespace db0::bindex::interface
         return static_cast<InputRangeT&>(input).insert(index, callback_ptr);
     }
 
+    template<typename DefinitionT, typename ContainerT>
+    std::pair<std::uint32_t, std::uint32_t>
+    insertHeteromorphicGenericImpl(void *self, typename DefinitionT::Containers::IInputRange &input,
+        std::function<void(typename DefinitionT::item_t)> *callback_ptr,
+        typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+    {
+        ContainerT &index = *reinterpret_cast<ContainerT*>(self);
+        using InputRangeT = typename DefinitionT::template IContainerInputRange<ContainerT>;
+        return static_cast<InputRangeT&>(input).insertHeteromorphic(index, callback_ptr, resolver_ptr);
+    }
+
     template<typename DefinitionT, typename ContainerT>
     std::size_t eraseGenericImpl(void *self, typename DefinitionT::Containers::IInputRange &input,
         std::function<void(typename DefinitionT::item_t)> *callback_ptr)
@@ -179,6 +203,18 @@ namespace db0::bindex::interface
         }
     };
 
+    template<typename DefinitionT, typename... T>
+    struct BulkInsertUniqueHeteromorphicFunctor<DefinitionT, db0::v_bindex<T...>> {
+        using CallbackT = std::function<void(typename DefinitionT::item_t)>;
+        static std::pair<std::uint32_t, std::uint32_t>
+        execute(void *this_ptr, typename DefinitionT::Containers::IInputRange &input, CallbackT *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            return insertHeteromorphicGenericImpl<DefinitionT, db0::v_bindex<T...>>(
+                this_ptr, input, callback_ptr, resolver_ptr);
+        }
+    };
+
     template <typename item_t, typename... T> struct InsertFunctor<item_t, db0::v_bindex<T...> > {
         static void execute(void *this_ptr, const item_t &item) {
             reinterpret_cast<db0::v_bindex<T...>*>(this_ptr)->insert(item);
@@ -333,6 +369,20 @@ namespace db0::bindex::interface
             return insertGenericImpl<DefinitionT, ContainerT>(this_ptr, input, callback_ptr);
         }
     };
+
+    template<typename DefinitionT, int N, typename... T>
+    struct BulkInsertUniqueHeteromorphicFunctor<DefinitionT, db0::v_sorted_sequence<typename DefinitionT::item_t, N, T...>>
+    {
+        using CallbackT = std::function<void(typename DefinitionT::item_t)>;
+        static std::pair<std::uint32_t, std::uint32_t>
+        execute(void *this_ptr, typename DefinitionT::Containers::IInputRange &input, CallbackT *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            using ContainerT = db0::v_sorted_sequence<typename DefinitionT::item_t, N, T...>;
+            return insertHeteromorphicGenericImpl<DefinitionT, ContainerT>(
+                this_ptr, input, callback_ptr, resolver_ptr);
+        }
+    };
     
     template <typename item_t, int N, typename... T> struct InsertFunctor<item_t, db0::v_sorted_sequence<item_t, N, T...> >
     {
@@ -492,6 +542,18 @@ namespace db0::bindex::interface
         }
     };
 
+    template<typename DefinitionT, typename... T>
+    struct BulkInsertUniqueHeteromorphicFunctor<DefinitionT, db0::v_sorted_vector<T...>> {
+        using CallbackT = std::function<void(typename DefinitionT::item_t)>;
+        static std::pair<std::uint32_t, std::uint32_t>
+        execute(void *this_ptr, typename DefinitionT::Containers::IInputRange &input, CallbackT *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            return insertHeteromorphicGenericImpl<DefinitionT, db0::v_sorted_vector<T...>>(
+                this_ptr, input, callback_ptr, resolver_ptr);
+        }
+    };
+
     template <typename item_t, typename... T> struct InsertFunctor<item_t, db0::v_sorted_vector<item_t, T...> > {
         static void execute(void *this_ptr, const item_t &item) {
             reinterpret_cast<db0::v_sorted_vector<item_t, T...>*>(this_ptr)->insert(item);
@@ -650,6 +712,18 @@ namespace db0::bindex::interface
             return insertGenericImpl<DefinitionT, db0::IttyIndex<T...>>(this_ptr, input, callback_ptr);
         }
     };
+
+    template<typename DefinitionT, typename... T>
+    struct BulkInsertUniqueHeteromorphicFunctor<DefinitionT, db0::IttyIndex<T...> > {
+        using CallbackT = std::function<void(typename DefinitionT::item_t)>;
+        static std::pair<std::uint32_t, std::uint32_t>
+        execute(void *this_ptr, typename DefinitionT::Containers::IInputRange &input, CallbackT *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            return insertHeteromorphicGenericImpl<DefinitionT, db0::IttyIndex<T...>>(
+                this_ptr, input, callback_ptr, resolver_ptr);
+        }
+    };
     
     template <typename item_t, typename... T> struct InsertFunctor<item_t, db0::IttyIndex<item_t, T...> >
     {
@@ -799,6 +873,19 @@ namespace db0::bindex::interface
             return insertGenericImpl<DefinitionT, db0::empty_index<T...> >(this_ptr, input, callback_ptr);
         }
     };
+
+    template<typename DefinitionT, typename... T>
+    struct BulkInsertUniqueHeteromorphicFunctor<DefinitionT, db0::empty_index<T...> >
+    {
+        using CallbackT = std::function<void(typename DefinitionT::item_t)>;
+        static std::pair<std::uint32_t, std::uint32_t>
+        execute(void *this_ptr, typename DefinitionT::Containers::IInputRange &input, CallbackT *callback_ptr,
+            typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            return insertHeteromorphicGenericImpl<DefinitionT, db0::empty_index<T...> >(
+                this_ptr, input, callback_ptr, resolver_ptr);
+        }
+    };
     
     template <typename item_t, typename... T>
     struct InsertFunctor<item_t, db0::empty_index<T...> >
@@ -928,6 +1015,7 @@ namespace db0::bindex::interface
             : m_ref(ref)
             , m_ptr(m_ref.get())
             , m_bulk_insert_unique_ptr(BulkInsertUniqueFunctor<DefinitionT, T>::execute)
+            , m_bulk_insert_unique_heteromorphic_ptr(BulkInsertUniqueHeteromorphicFunctor<DefinitionT, T>::execute)
             , m_insert_ptr(InsertFunctor<item_t, T>::execute)
             , m_bulk_erase_ptr(BulkEraseFunctor<DefinitionT, T>::execute)
             , m_empty_ptr(EmptyFunctor<item_t, T>::execute)
@@ -956,6 +1044,14 @@ namespace db0::bindex::interface
             db0::bindex::GenericInputRange<InputIterator, DefinitionT> input(begin, end);
             return m_bulk_insert_unique_ptr(m_ptr, input, callback_ptr);
         }
+
+        template <typename ItemT, typename InputIterator>
+        std::pair<std::uint32_t, std::uint32_t> bulkInsertUniqueHeteromorphic(InputIterator begin, InputIterator end,
+            std::function<void(ItemT)> *callback_ptr, typename DefinitionT::HeteromorphicResolverT *resolver_ptr)
+        {
+            db0::bindex::GenericInputRange<InputIterator, DefinitionT> input(begin, end);
+            return m_bulk_insert_unique_heteromorphic_ptr(m_ptr, input, callback_ptr, resolver_ptr);
+        }
         
         /**
          * Insert single item
@@ -1068,6 +1164,7 @@ namespace db0::bindex::interface
         // pointer to actual data collection (persisted in m_ref)
         void *m_ptr = nullptr;
         bulkInsertUniquePtr<DefinitionT> m_bulk_insert_unique_ptr = nullptr;
+        bulkInsertUniqueHeteromorphicPtr<DefinitionT> m_bulk_insert_unique_heteromorphic_ptr = nullptr;
         insertPtr<item_t> m_insert_ptr = nullptr;
         bulkErasePtr<DefinitionT> m_bulk_erase_ptr = nullptr;
         emptyPtr<item_t> m_empty_ptr = nullptr;

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/core/collections/b_index/mb_index.hpp

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <type_traits>
 #include <unordered_set>
 
 #include "mb_index_def.hpp"
@@ -10,6 +11,7 @@
 #include "bindex_interface.hpp"
 #include "bindex_iterator.hpp"
 #include <dbzero/core/serialization/Serializable.hpp>
+#include <dbzero/core/memory/UniqueRef.hpp>
 
 namespace db0
 
@@ -33,9 +35,10 @@ namespace db0
         using item_t = typename definition_t::item_t;
         using item_comp_t = typename definition_t::item_comp_t;
 
-        using interface_t = bindex::interface::Impl<definition_t>;
+		using interface_t = bindex::interface::Impl<definition_t>;
         using iterator_t = bindex::iterator::Impl<item_t>;
 		using CallbackT = std::function<void(item_t)>;
+		using HeteromorphicResolverT = typename definition_t::HeteromorphicResolverT;
 
         /**
          * 0 = empty_index (0 elements)
@@ -172,6 +175,12 @@ namespace db0
          */
 		bindex::type assessIndexType(std::size_t final_size) const
 		{
+            if constexpr (std::is_same_v<item_t, UniqueRef>) {
+                if (final_size == 0) {
+                    return bindex::type::empty;
+                }
+                return (final_size <= m_sv_limit) ? bindex::type::sorted_vector : bindex::type::bindex;
+            }
 			// depending on final size assess resulting index type
 			switch (final_size)
 			{
@@ -414,6 +423,49 @@ namespace db0
 			return m_interface.bulkInsertUnique(begin, end, callback_ptr);
 		}
 
+		/**
+		 * Like bulkInsertUnique, but duplicate identities with different bitwise values are resolved by callback.
+		 */
+		template <typename InputIterator>
+		std::pair<std::uint32_t, std::uint32_t> bulkInsertUniqueHeteromorphic(InputIterator begin, InputIterator end,
+			CallbackT *callback_ptr = nullptr, HeteromorphicResolverT *resolver_ptr = nullptr)
+		{
+			if (begin == end) {
+				return std::make_pair(0,0);
+			}
+
+			bindex::type type = getIndexType();
+			std::size_t unique_count = m_interface.countUnique(begin, end, m_sv_limit + 1);
+			if (unique_count == 0) {
+				return m_interface.bulkInsertUniqueHeteromorphic(begin, end, callback_ptr, resolver_ptr);
+			}
+
+			bindex::type type_after_insertion = getIndexTypeAfterInsertion(unique_count);
+			if (type_after_insertion > type) {
+				if (type_after_insertion == bindex::type::bindex) {
+					morphTo<bindex::type::bindex>();
+				} else if (type_after_insertion == bindex::type::sorted_vector || resolver_ptr) {
+					morphTo<bindex::type::sorted_vector>();
+				} else {
+					std::size_t diff = 0;
+					if (type_after_insertion == bindex::type::itty) {
+						assert(type==bindex::type::empty);
+						diff = morphToAndInsert<bindex::type::itty>(begin, end, callback_ptr);
+					} else if (type_after_insertion == bindex::type::array_2) {
+						diff = morphToAndInsert<bindex::type::array_2>(begin, end, callback_ptr);
+					} else if (type_after_insertion==bindex::type::array_3) {
+						diff = morphToAndInsert<bindex::type::array_3>(begin, end, callback_ptr);
+					} else if (type_after_insertion==bindex::type::array_4) {
+						diff = morphToAndInsert<bindex::type::array_4>(begin, end, callback_ptr);
+					} else {
+						assert(false);
+					}
+					return std::make_pair(std::distance(begin, end), diff);
+				}
+			}
+			return m_interface.bulkInsertUniqueHeteromorphic(begin, end, callback_ptr, resolver_ptr);
+		}
+
 		bool isNull() const {
 			return m_morph.isNull();
 		}

{dbzero-0.6.0 → dbzero-0.6.1}/src/dbzero/core/collections/b_index/mb_index_def.hpp

@@ -32,6 +32,7 @@ namespace db0::bindex
         using vector_t = v_sorted_vector<item_t, AddrT, item_comp_t>;
         using bindex_t = v_bindex<item_t, AddrT, item_comp_t>;
         using CallbackT = std::function<void(item_t)>;
+        using HeteromorphicResolverT = std::function<bool(const item_t &stored, const item_t &incoming, item_t &resolved)>;
 
         template<typename ContainerType>
         class IContainerInputRange 
@@ -40,6 +41,8 @@ namespace db0::bindex
             virtual ~IContainerInputRange() = default;
 
             virtual std::pair<std::uint32_t, std::uint32_t> insert(ContainerType&, CallbackT *callback_ptr) = 0;
+            virtual std::pair<std::uint32_t, std::uint32_t> insertHeteromorphic(ContainerType&,
+                CallbackT *callback_ptr, HeteromorphicResolverT *resolver_ptr) = 0;
             virtual std::size_t erase(ContainerType&, CallbackT *callback_ptr) = 0;
             virtual std::size_t countNew(const ContainerType&, std::size_t max_count) = 0;
             virtual std::size_t countExisting(const ContainerType&, std::size_t max_count) = 0;