Update to version v5.11.1

Author: APl

bindings/consts.go

@@ -2,7 +2,7 @@ package bindings
 
 const CInt32Max = int(^uint32(0) >> 1)
 
-const ReindexerVersion = "v5.11.0"
+const ReindexerVersion = "v5.11.1"
 
 // public go consts from type_consts.h and reindexer_ctypes.h
 const (

changelog.md

@@ -1,3 +1,12 @@
+# Version 5.11.1 (05.03.2026)
+## Fulltext
+- [fix] Fixed possible heap-use-after in composite fulltext indexes, created over non-indexed fields
+- [fix] Fixed composite fulltext index cache invalidation after `UPDATE`-queries
+- [fix] Fixed deleted docs handling, when selection results exceeding `merge_limit` and there are multiple build steps in incremental index
+
+## Vector indexes
+- [fix] Fixed possible buffer overflow in transactions logic in case of multithreading insertion into `HNSW`
+
 # Version 5.11.0 (06.02.2026)
 ## Core
 - [fea] Optimized indexes memory layout for namespaces with large amount of items. Index `IdSet`-structures now produce noticeably less overhead

cpp_src/CMakeLists.txt

@@ -67,7 +67,7 @@ else()
   option(LINK_RESOURCES "Link web resources as binary data" ON)
 endif()
 
-set (REINDEXER_VERSION_DEFAULT "5.11.0")
+set (REINDEXER_VERSION_DEFAULT "5.11.1")
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "RelWithDebInfo")

cpp_src/cmd/reindexer_server/contrib/Dockerfile

@@ -31,7 +31,7 @@ RUN mkdir build && \
 
 FROM alpine:3.22
 
-ARG RX_VERSION=v5.11.0
+ARG RX_VERSION=v5.11.1
 
 COPY --from=build /usr/local /usr/local
 COPY --from=build /entrypoint.sh /entrypoint.sh

cpp_src/core/ft/ft_fast/mergerimpl.h

@@ -504,6 +504,9 @@ void Merger<IdCont, MergeDataType, MergeOffsetT>::collectRestrictingMask(std::ve
 
 	size_t minScoreDocsTaken = 0;
 	for (size_t i = 0; i < docsScores.size(); i++) {
+		if (vdocs[i].IsRemoved() || mergeStatuses_[i] == FtMergeStatuses::kExcluded) {
+			continue;
+		}
 		if (docsScores[i] > minScore) {
 			restrictingMask_.set(i);
 		} else if (docsScores[i] == minScore && minScoreDocsTaken < minScoreDocs) {

cpp_src/core/index/indextext/fastindextext.cc

@@ -61,6 +61,7 @@ Variant FastIndexText<T>::Upsert(const Variant& key, IdType id, bool& clearCache
 		this->tracker_.markUpdated(this->idx_map, keyIt, false);
 	} else {
 		this->delMemStat(keyIt);
+		Base::refreshCompositeKeyImpl(key, keyIt);
 	}
 	if (keyIt->second.Unsorted().Add(id, this->opts_.IsPK() ? IdSetEditMode::Ordered : IdSetEditMode::Auto, 0)) {
 		this->isBuilt_ = false;
@@ -108,7 +109,7 @@ void FastIndexText<T>::Delete(const Variant& key, IdType id, MustExist mustExist
 																	   {strHolder, this->KeyType().template Is<KeyValueType::String>()});
 		} else {
 			static_assert(is_payload_map_v<T>);
-			this->idx_map.template erase<no_deep_clean>(keyIt);
+			this->idx_map.template erase<no_deep_clean>(keyIt, strHolder);
 		}
 	} else {
 		this->addMemStat(keyIt);
@@ -200,6 +201,7 @@ IdSet::Ptr FastIndexText<T>::afterSelect(FtCtx& ftCtx, MergeType&& mergeData, Ra
 		case RankSortType::RankOnly:
 			for (auto& vid : mergeData) {
 				auto& vdoc = holder.vdocs_[vid.id.ToNumber()];
+				assertrx_dbg(!vdoc.IsRemoved());
 				assertrx_throw(!vdoc.keyEntry->Unsorted().empty());
 				cnt += vdoc.keyEntry->Sorted(0).size();
 				++relevantDocs;
@@ -562,8 +564,8 @@ std::unique_ptr<Index> FastIndexText_New(const IndexDef& idef, PayloadType&& pay
 			return std::make_unique<FastIndexText<unordered_str_map<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
 																				  cacheCfg);
 		case IndexCompositeFastFT:
-			return std::make_unique<FastIndexText<unordered_payload_map<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
-																					  cacheCfg);
+			return std::make_unique<FastIndexText<unordered_payload_map_ft<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
+																						 cacheCfg);
 		case IndexStrHash:
 		case IndexStrBTree:
 		case IndexIntBTree:

cpp_src/core/index/indextext/fuzzyindextext.cc

@@ -79,8 +79,8 @@ std::unique_ptr<Index> FuzzyIndexText_New(const IndexDef& idef, PayloadType&& pa
 			return std::make_unique<FuzzyIndexText<unordered_str_map<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
 																				   cacheCfg);
 		case IndexCompositeFuzzyFT:
-			return std::make_unique<FuzzyIndexText<unordered_payload_map<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
-																					   cacheCfg);
+			return std::make_unique<FuzzyIndexText<unordered_payload_map_ft<FtKeyEntry>>>(idef, std::move(payloadType), std::move(fields),
+																						  cacheCfg);
 		case IndexStrHash:
 		case IndexStrBTree:
 		case IndexIntBTree:

cpp_src/core/index/indextext/indextext.cc

@@ -35,6 +35,16 @@ IndexText<T>::IndexText(const IndexDef& idef, PayloadType&& payloadType, FieldsS
 	this->selectKeyType_ = KeyValueType::String{};
 	initSearchers();
 }
+
+template <typename T>
+bool IndexText<T>::RefreshCompositeKey(const Variant& key) noexcept {
+	if (Base::RefreshCompositeKey(key)) {
+		cache_ft_.Clear();
+		return true;
+	}
+	return false;
+}
+
 // Generic implementation for string index
 template <typename T>
 void IndexText<T>::initSearchers() {
@@ -78,6 +88,15 @@ void IndexText<T>::SetOpts(const IndexOpts& opts) {
 	}
 }
 
+template <typename T>
+bool IndexText<T>::HoldsStrings() const noexcept {
+	if constexpr (is_payload_map_v<T>) {
+		return this->idx_map.have_str_fields() || Base::HoldsStrings();
+	} else {
+		return Base::HoldsStrings();
+	}
+}
+
 template <typename T>
 void IndexText<T>::ReconfigureCache(const NamespaceCacheConfigData& cacheCfg) {
 	if (cacheMaxSize_ != cacheCfg.ftIdxCacheSize || hitsToCache_ != cacheCfg.ftIdxHitsToCache) {
@@ -243,7 +262,19 @@ FieldsGetter IndexText<T>::Getter() {
 	return FieldsGetter(this->Fields(), this->payloadType_, this->KeyType());
 }
 
+template <typename T>
+void IndexText<T>::refreshCompositeKeyImpl(const Variant& key, typename T::iterator& keyIt) noexcept {
+	if constexpr (is_payload_map_v<T>) {
+		auto& newKey = static_cast<const PayloadValue&>(key);
+		this->tracker_.refreshKey(keyIt->first, newKey);
+		keyIt.refresh_key(PayloadValueWithHash(PayloadValue(newKey), this->payloadType_, this->Fields()));
+	} else {
+		(void)key;
+		(void)keyIt;
+	}
+}
+
 template class IndexText<unordered_str_map<FtKeyEntry>>;
-template class IndexText<unordered_payload_map<FtKeyEntry>>;
+template class IndexText<unordered_payload_map_ft<FtKeyEntry>>;
 
 }  // namespace reindexer

cpp_src/core/index/indextext/indextext.h

@@ -21,6 +21,7 @@ class [[nodiscard]] IndexText : public IndexUnordered<Map> {
 public:
 	IndexText(const IndexDef& idef, PayloadType&& payloadType, FieldsSet&& fields, const NamespaceCacheConfigData& cacheCfg);
 
+	bool RefreshCompositeKey(const Variant& key) noexcept override;
 	SelectKeyResults SelectKey(const VariantArray& keys, CondType, SortType, const Index::SelectContext&, const RdxContext&) override final;
 	SelectKeyResults SelectKey(const VariantArray& keys, CondType, const Index::SelectContext&, FtPreselectT&&, const RdxContext&) override;
 
@@ -39,6 +40,7 @@ class [[nodiscard]] IndexText : public IndexUnordered<Map> {
 		commitFulltextImpl();
 		this->isBuilt_ = true;
 	}
+	bool HoldsStrings() const noexcept override;
 	void SetSortedIdxCount(int) override final {}
 	void DestroyCache() override {
 		Base::DestroyCache();
@@ -68,7 +70,7 @@ class [[nodiscard]] IndexText : public IndexUnordered<Map> {
 
 	void initSearchers();
 	FieldsGetter Getter();
-
+	void refreshCompositeKeyImpl(const Variant& key, typename Map::iterator& keyIt) noexcept override;
 	FtIdSetCache cache_ft_;
 	size_t cacheMaxSize_;
 	uint32_t hitsToCache_;

cpp_src/core/index/indexunordered.cc

@@ -1,7 +1,6 @@
 #include "indexunordered.h"
 #include "core/dbconfig.h"
 #include "core/index/indextext/ftkeyentry.h"
-#include "core/index/payload_map.h"
 #include "core/index/string_map.h"
 #include "core/indexdef.h"
 #include "core/rdxcontext.h"
@@ -82,8 +81,8 @@ IndexUnordered<unordered_str_map<FtKeyEntry>>::IndexUnordered(const IndexDef& id
 	  hitsToCache_(cacheCfg.idxIdsetHitsToCache) {}
 
 template <>
-IndexUnordered<unordered_payload_map<FtKeyEntry>>::IndexUnordered(const IndexDef& idef, PayloadType&& payloadType, FieldsSet&& fields,
-																  const NamespaceCacheConfigData& cacheCfg)
+IndexUnordered<unordered_payload_map_ft<FtKeyEntry>>::IndexUnordered(const IndexDef& idef, PayloadType&& payloadType, FieldsSet&& fields,
+																	 const NamespaceCacheConfigData& cacheCfg)
 	: Base(idef, std::move(payloadType), std::move(fields)),
 	  idx_map(PayloadType{Base::GetPayloadType()}, FieldsSet{Base::Fields()}),
 	  cacheMaxSize_(cacheCfg.idxIdsetCacheSize),
@@ -219,6 +218,7 @@ Variant IndexUnordered<T>::Upsert(const Variant& key, IdType id, bool& clearCach
 	if (keyIt == this->idx_map.end()) {
 		keyIt = this->idx_map.insert({static_cast<key_type>(key), typename T::mapped_type()}).first;
 	} else {
+		refreshCompositeKeyImpl(key, keyIt);
 		delMemStat(keyIt);
 		if (this->opts_.IsPK()) {
 			WrSerializer wrser;
@@ -278,9 +278,12 @@ void IndexUnordered<T>::Delete(const Variant& key, IdType id, MustExist mustExis
 		if constexpr (is_str_map_v<T>) {
 			idx_map.template erase<StringMapEntryCleaner<true>>(
 				keyIt, {strHolder, this->KeyType().template Is<KeyValueType::String>() && this->opts_.GetCollateMode() == CollateNone});
+		} else if constexpr (is_ft_payload_map_v<T>) {
+			idx_map.template erase<DeepClean>(keyIt, strHolder);
 		} else {
 			idx_map.template erase<DeepClean>(keyIt);
 		}
+
 	} else {
 		addMemStat(keyIt);
 		this->tracker_.markUpdated(this->idx_map, keyIt);
@@ -299,27 +302,10 @@ bool IndexUnordered<T>::RefreshCompositeKey(const Variant& key) noexcept {
 			assertrx_dbg(false);
 			return false;
 		}
-		delMemStat(keyIt);
 
-#ifdef RX_WITH_STDLIB_DEBUG
-		const hash_composite hashF(this->GetPayloadType(), this->Fields());
-		assertrx_dbg(hashF(keyIt->first) == hashF(static_cast<const PayloadValue&>(key)));
-		const equal_composite equalF(this->GetPayloadType(), this->Fields());
-		assertrx_dbg(equalF(keyIt->first, static_cast<const PayloadValue&>(key)));
-		const less_composite lessF(PayloadType(this->GetPayloadType()), FieldsSet(this->Fields()));
-		assertrx_dbg(!lessF(keyIt->first, static_cast<const PayloadValue&>(key)));
-		assertrx_dbg(!lessF(static_cast<const PayloadValue&>(key), keyIt->first));
-#endif	// RX_WITH_STDLIB_DEBUG
-
-		auto& newKey = static_cast<const PayloadValue&>(key);
-		this->tracker_.refreshKey(keyIt->first, static_cast<const PayloadValue&>(key));
-		if constexpr (std::is_same_v<typename T::key_type, PayloadValueWithHash>) {
-			const_cast<PayloadValueWithHash&>(keyIt->first) =
-				PayloadValueWithHash(PayloadValue(newKey), this->payloadType_, this->Fields());
+		delMemStat(keyIt);
 
-		} else {
-			const_cast<PayloadValue&>(keyIt->first) = newKey;
-		}
+		refreshCompositeKeyImpl(key, keyIt);
 
 		addMemStat(keyIt);
 		cache_.ResetImpl();
@@ -602,6 +588,34 @@ IndexMemStat IndexUnordered<T>::GetMemStat(const RdxContext& ctx) {
 	return ret;
 }
 
+template <typename T>
+void IndexUnordered<T>::refreshCompositeKeyImpl(const Variant& key, typename T::iterator& keyIt) noexcept {
+	if constexpr (is_payload_map_v<T>) {
+#ifdef RX_WITH_STDLIB_DEBUG
+		const hash_composite hashF(this->GetPayloadType(), this->Fields());
+		assertrx_dbg(hashF(keyIt->first) == hashF(static_cast<const PayloadValue&>(key)));
+		const equal_composite equalF(this->GetPayloadType(), this->Fields());
+		assertrx_dbg(equalF(keyIt->first, static_cast<const PayloadValue&>(key)));
+		const less_composite lessF(PayloadType(this->GetPayloadType()), FieldsSet(this->Fields()));
+		assertrx_dbg(!lessF(keyIt->first, static_cast<const PayloadValue&>(key)));
+		assertrx_dbg(!lessF(static_cast<const PayloadValue&>(key), keyIt->first));
+#endif	// RX_WITH_STDLIB_DEBUG
+
+		auto& newKey = static_cast<const PayloadValue&>(key);
+		this->tracker_.refreshKey(keyIt->first, static_cast<const PayloadValue&>(key));
+		if constexpr (std::is_same_v<typename T::key_type, PayloadValueWithHash>) {
+			const_cast<PayloadValueWithHash&>(keyIt->first) =
+				PayloadValueWithHash(PayloadValue(newKey), this->payloadType_, this->Fields());
+
+		} else {
+			const_cast<PayloadValue&>(keyIt->first) = newKey;
+		}
+	} else {
+		(void)key;
+		(void)keyIt;
+	}
+}
+
 template <typename T>
 template <typename S>
 void IndexUnordered<T>::dump(S& os, std::string_view step, std::string_view offset) const {
@@ -724,7 +738,7 @@ template class IndexUnordered<payload_map<Index::KeyEntry>>;
 
 template class IndexUnordered<unordered_str_map<FtKeyEntry>>;
 
-template class IndexUnordered<unordered_payload_map<FtKeyEntry>>;
+template class IndexUnordered<unordered_payload_map_ft<FtKeyEntry>>;
 
 template class IndexUnordered<unordered_uuid_map<Index::KeyEntryPK>>;
 template class IndexUnordered<unordered_uuid_map<Index::KeyEntryPlain>>;