From 7c412ba7054f1bf8a7e75f23fc1e7368e06bc7a4 Mon Sep 17 00:00:00 2001 From: Aksha Thakkar Date: Fri, 8 Aug 2025 03:03:49 +0000 Subject: [PATCH 1/2] Adding suffix 'field' to classes inheriting IndexBase --- src/commands/filter_parser.cc | 8 ++-- src/commands/filter_parser.h | 4 +- src/coordinator/search_converter.cc | 4 +- src/index_schema.cc | 18 ++++----- src/index_schema.h | 4 +- src/indexes/numeric.cc | 46 ++++++++++----------- src/indexes/numeric.h | 6 +-- src/indexes/tag.cc | 50 +++++++++++------------ src/indexes/tag.h | 4 +- src/indexes/text.h | 4 +- src/indexes/vector_base.cc | 62 ++++++++++++++--------------- src/indexes/vector_base.h | 8 ++-- src/indexes/vector_flat.cc | 42 +++++++++---------- src/indexes/vector_flat.h | 14 +++---- src/indexes/vector_hnsw.cc | 42 +++++++++---------- src/indexes/vector_hnsw.h | 12 +++--- src/query/planner.cc | 2 +- src/query/planner.h | 2 +- src/query/predicate.cc | 4 +- src/query/predicate.h | 16 ++++---- src/query/response_generator.cc | 2 +- src/query/search.cc | 20 +++++----- src/query/search.h | 4 +- testing/common.cc | 2 +- testing/filter_test.cc | 12 +++--- testing/ft_search_parser_test.cc | 6 +-- testing/index_schema_test.cc | 26 ++++++------ testing/numeric_index_test.cc | 2 +- testing/query/fanout_test.cc | 4 +- testing/search_test.cc | 50 +++++++++++------------ testing/tag_index_test.cc | 28 ++++++------- testing/vector_test.cc | 38 +++++++++--------- 32 files changed, 273 insertions(+), 273 deletions(-) diff --git a/src/commands/filter_parser.cc b/src/commands/filter_parser.cc index 1250f0a88..491320a3a 100644 --- a/src/commands/filter_parser.cc +++ b/src/commands/filter_parser.cc @@ -200,7 +200,7 @@ FilterParser::ParseNumericPredicate(const std::string& attribute_alias) { pos_)); } auto numeric_index = - dynamic_cast(index.value().get()); + dynamic_cast(index.value().get()); return std::make_unique( numeric_index, attribute_alias, identifier, start, is_inclusive_start, end, is_inclusive_end); @@ -218,8 +218,8 @@ absl::StatusOr FilterParser::ParseTagString() { } absl::StatusOr> FilterParser::ParseTags( - absl::string_view tag_string, indexes::Tag* tag_index) const { - return indexes::Tag::ParseSearchTags(tag_string, tag_index->GetSeparator()); + absl::string_view tag_string, indexes::TagField* tag_index) const { + return indexes::TagField::ParseSearchTags(tag_string, tag_index->GetSeparator()); } absl::StatusOr> @@ -233,7 +233,7 @@ FilterParser::ParseTagPredicate(const std::string& attribute_alias) { auto identifier = index_schema_.GetIdentifier(attribute_alias).value(); filter_identifiers_.insert(identifier); - auto tag_index = dynamic_cast(index.value().get()); + auto tag_index = dynamic_cast(index.value().get()); VMSDK_ASSIGN_OR_RETURN(auto tag_string, ParseTagString()); VMSDK_ASSIGN_OR_RETURN(auto parsed_tags, ParseTags(tag_string, tag_index)); return std::make_unique( diff --git a/src/commands/filter_parser.h b/src/commands/filter_parser.h index 64bdb781c..8a9e2c983 100644 --- a/src/commands/filter_parser.h +++ b/src/commands/filter_parser.h @@ -21,7 +21,7 @@ namespace valkey_search { namespace indexes { -class Tag; +class TagField; } // namespace indexes struct FilterParseResults { std::unique_ptr root_predicate; @@ -61,7 +61,7 @@ class FilterParser { absl::StatusOr ParseTagString(); absl::StatusOr> ParseTags( - absl::string_view tag_string, indexes::Tag* tag_index) const; + absl::string_view tag_string, indexes::TagField* tag_index) const; }; namespace options { diff --git a/src/coordinator/search_converter.cc b/src/coordinator/search_converter.cc index b399f7377..35e3703c6 100644 --- a/src/coordinator/search_converter.cc +++ b/src/coordinator/search_converter.cc @@ -47,7 +47,7 @@ absl::StatusOr> GRPCPredicateToPredicate( auto identifier, index_schema->GetIdentifier(predicate.tag().attribute_alias())); attribute_identifiers.insert(identifier); - auto tag_index = dynamic_cast(index.get()); + auto tag_index = dynamic_cast(index.get()); VMSDK_ASSIGN_OR_RETURN( auto parsed_tags, tag_index->ParseSearchTags(predicate.tag().raw_tag_string(), @@ -70,7 +70,7 @@ absl::StatusOr> GRPCPredicateToPredicate( auto identifier, index_schema->GetIdentifier(predicate.numeric().attribute_alias())); attribute_identifiers.insert(identifier); - auto numeric_index = dynamic_cast(index.get()); + auto numeric_index = dynamic_cast(index.get()); auto numeric_predicate = std::make_unique( numeric_index, predicate.numeric().attribute_alias(), identifier, predicate.numeric().start(), predicate.numeric().is_inclusive_start(), diff --git a/src/index_schema.cc b/src/index_schema.cc index 702458d50..641e1a0ce 100644 --- a/src/index_schema.cc +++ b/src/index_schema.cc @@ -77,10 +77,10 @@ absl::StatusOr> IndexFactory( const auto &index = attribute.index(); switch (index.index_type_case()) { case data_model::Index::IndexTypeCase::kTagIndex: { - return std::make_shared(index.tag_index()); + return std::make_shared(index.tag_index()); } case data_model::Index::IndexTypeCase::kNumericIndex: { - return std::make_shared(index.numeric_index()); + return std::make_shared(index.numeric_index()); } case data_model::Index::IndexTypeCase::kVectorIndex: { switch (index.vector_index().algorithm_case()) { @@ -90,11 +90,11 @@ absl::StatusOr> IndexFactory( VMSDK_ASSIGN_OR_RETURN( auto index, (iter.has_value()) - ? indexes::VectorHNSW::LoadFromRDB( + ? indexes::VectorHNSWField::LoadFromRDB( ctx, &index_schema->GetAttributeDataType(), index.vector_index(), attribute.identifier(), std::move(*iter)) - : indexes::VectorHNSW::Create( + : indexes::VectorHNSWField::Create( index.vector_index(), attribute.identifier(), index_schema->GetAttributeDataType().ToProto())); index_schema->SubscribeToVectorExternalizer( @@ -115,11 +115,11 @@ absl::StatusOr> IndexFactory( VMSDK_ASSIGN_OR_RETURN( auto index, (iter.has_value()) - ? indexes::VectorFlat::LoadFromRDB( + ? indexes::VectorFlatField::LoadFromRDB( ctx, &index_schema->GetAttributeDataType(), index.vector_index(), attribute.identifier(), std::move(*iter)) - : indexes::VectorFlat::Create( + : indexes::VectorFlatField::Create( index.vector_index(), attribute.identifier(), index_schema->GetAttributeDataType().ToProto())); index_schema->SubscribeToVectorExternalizer( @@ -855,7 +855,7 @@ absl::Status IndexSchema::RDBSave(SafeRDB *rdb) const { << this->name_ << " attribute: " << attribute.first << " to RDB"; RDBChunkOutputStream key_to_id_chunked_out(rdb); VMSDK_RETURN_IF_ERROR( - dynamic_cast( + dynamic_cast( attribute.second.GetIndex().get()) ->SaveTrackedKeys(std::move(key_to_id_chunked_out))) << "IO error while saving Key to ID mapping (index name: " @@ -909,7 +909,7 @@ absl::StatusOr> IndexSchema::LoadFromRDB( "(index: %s, attribute: %s)", index_schema->GetName(), attribute.alias())); } - auto vector_index = dynamic_cast(index.get()); + auto vector_index = dynamic_cast(index.get()); VMSDK_RETURN_IF_ERROR(vector_index->LoadTrackedKeys( ctx, &index_schema->GetAttributeDataType(), supplemental_iter.IterateChunks())); @@ -1092,7 +1092,7 @@ size_t IndexSchema::GetMutatedRecordsSize() const { } void IndexSchema::SubscribeToVectorExternalizer( - absl::string_view attribute_identifier, indexes::VectorBase *vector_index) { + absl::string_view attribute_identifier, indexes::VectorBaseField *vector_index) { vector_externalizer_subscriptions_[attribute_identifier] = vector_index; } diff --git a/src/index_schema.h b/src/index_schema.h index 9e4b8648f..20f62af45 100644 --- a/src/index_schema.h +++ b/src/index_schema.h @@ -149,7 +149,7 @@ class IndexSchema : public KeyspaceEventSubscription, void MarkAsDestructing(); void ProcessMultiQueue(); void SubscribeToVectorExternalizer(absl::string_view attribute_identifier, - indexes::VectorBase *vector_index); + indexes::VectorBaseField *vector_index); protected: IndexSchema(ValkeyModuleCtx *ctx, @@ -190,7 +190,7 @@ class IndexSchema : public KeyspaceEventSubscription, }; vmsdk::MainThreadAccessGuard> backfill_job_; - absl::flat_hash_map + absl::flat_hash_map vector_externalizer_subscriptions_; void VectorExternalizer(const InternedStringPtr &key, absl::string_view attribute_identifier, diff --git a/src/indexes/numeric.cc b/src/indexes/numeric.cc index 450a8105c..c5261569a 100644 --- a/src/indexes/numeric.cc +++ b/src/indexes/numeric.cc @@ -38,13 +38,13 @@ std::optional ParseNumber(absl::string_view data) { } } // namespace -Numeric::Numeric(const data_model::NumericIndex& numeric_index_proto) +NumericField::NumericField(const data_model::NumericIndex& numeric_index_proto) : IndexBase(IndexerType::kNumeric) { index_ = std::make_unique(); } -absl::StatusOr Numeric::AddRecord(const InternedStringPtr& key, - absl::string_view data) { +absl::StatusOr NumericField::AddRecord(const InternedStringPtr& key, + absl::string_view data) { auto value = ParseNumber(data); absl::MutexLock lock(&index_mutex_); if (!value.has_value()) { @@ -61,8 +61,8 @@ absl::StatusOr Numeric::AddRecord(const InternedStringPtr& key, return true; } -absl::StatusOr Numeric::ModifyRecord(const InternedStringPtr& key, - absl::string_view data) { +absl::StatusOr NumericField::ModifyRecord(const InternedStringPtr& key, + absl::string_view data) { auto value = ParseNumber(data); if (!value.has_value()) { [[maybe_unused]] auto res = @@ -81,8 +81,8 @@ absl::StatusOr Numeric::ModifyRecord(const InternedStringPtr& key, return true; } -absl::StatusOr Numeric::RemoveRecord(const InternedStringPtr& key, - DeletionType deletion_type) { +absl::StatusOr NumericField::RemoveRecord(const InternedStringPtr& key, + DeletionType deletion_type) { absl::MutexLock lock(&index_mutex_); if (deletion_type == DeletionType::kRecord) { // If key is DELETED, remove it from untracked_keys_. @@ -101,7 +101,7 @@ absl::StatusOr Numeric::RemoveRecord(const InternedStringPtr& key, return true; } -int Numeric::RespondWithInfo(ValkeyModuleCtx* ctx) const { +int NumericField::RespondWithInfo(ValkeyModuleCtx* ctx) const { ValkeyModule_ReplyWithSimpleString(ctx, "type"); ValkeyModule_ReplyWithSimpleString(ctx, "NUMERIC"); ValkeyModule_ReplyWithSimpleString(ctx, "size"); @@ -111,19 +111,19 @@ int Numeric::RespondWithInfo(ValkeyModuleCtx* ctx) const { return 4; } -bool Numeric::IsTracked(const InternedStringPtr& key) const { +bool NumericField::IsTracked(const InternedStringPtr& key) const { absl::MutexLock lock(&index_mutex_); return tracked_keys_.contains(key); } -std::unique_ptr Numeric::ToProto() const { +std::unique_ptr NumericField::ToProto() const { auto index_proto = std::make_unique(); auto numeric_index = std::make_unique(); index_proto->set_allocated_numeric_index(numeric_index.release()); return index_proto; } -const double* Numeric::GetValue(const InternedStringPtr& key) const { +const double* NumericField::GetValue(const InternedStringPtr& key) const { // Note that the Numeric index is not mutated while the time sliced mutex is // in a read mode and therefor it is safe to skip lock acquiring. if (auto it = tracked_keys_.find(key); it != tracked_keys_.end()) { @@ -132,7 +132,7 @@ const double* Numeric::GetValue(const InternedStringPtr& key) const { return nullptr; } -std::unique_ptr Numeric::Search( +std::unique_ptr NumericField::Search( const query::NumericPredicate& predicate, bool negate) const { EntriesRange entries_range; const auto& btree = index_->GetBtree(); @@ -153,7 +153,7 @@ std::unique_ptr Numeric::Search( : btree.lower_bound(predicate.GetEnd()); ; additional_entries_range.second = btree.end(); - return std::make_unique( + return std::make_unique( entries_range, size + untracked_keys_.size(), additional_entries_range, &untracked_keys_); } @@ -167,11 +167,11 @@ std::unique_ptr Numeric::Search( size_t size = index_->GetCount(predicate.GetStart(), predicate.GetEnd(), predicate.IsStartInclusive(), predicate.IsEndInclusive()); - return std::make_unique(entries_range, size); + return std::make_unique(entries_range, size); } -bool Numeric::EntriesFetcherIterator::NextKeys( - const Numeric::EntriesRange& range, BTreeNumericIndex::ConstIterator& iter, +bool NumericField::EntriesFetcherIterator::NextKeys( + const NumericField::EntriesRange& range, BTreeNumericIndex::ConstIterator& iter, std::optional& keys_iter) { while (iter != range.second) { if (!keys_iter.has_value()) { @@ -188,7 +188,7 @@ bool Numeric::EntriesFetcherIterator::NextKeys( return false; } -Numeric::EntriesFetcherIterator::EntriesFetcherIterator( +NumericField::EntriesFetcherIterator::EntriesFetcherIterator( const EntriesRange& entries_range, const std::optional& additional_entries_range, const InternedStringSet* untracked_keys) @@ -201,7 +201,7 @@ Numeric::EntriesFetcherIterator::EntriesFetcherIterator( } } -bool Numeric::EntriesFetcherIterator::Done() const { +bool NumericField::EntriesFetcherIterator::Done() const { return entries_iter_ == entries_range_.second && (!additional_entries_range_.has_value() || additional_entries_iter_ == @@ -211,7 +211,7 @@ bool Numeric::EntriesFetcherIterator::Done() const { untracked_keys_iter_ == untracked_keys_->end())); } -void Numeric::EntriesFetcherIterator::Next() { +void NumericField::EntriesFetcherIterator::Next() { if (NextKeys(entries_range_, entries_iter_, entry_keys_iter_)) { return; } @@ -229,7 +229,7 @@ void Numeric::EntriesFetcherIterator::Next() { } } -const InternedStringPtr& Numeric::EntriesFetcherIterator::operator*() const { +const InternedStringPtr& NumericField::EntriesFetcherIterator::operator*() const { if (entries_iter_ != entries_range_.second) { DCHECK(entry_keys_iter_ != entries_iter_->second.end()); return *entry_keys_iter_.value(); @@ -245,16 +245,16 @@ const InternedStringPtr& Numeric::EntriesFetcherIterator::operator*() const { return *untracked_keys_iter_.value(); } -size_t Numeric::EntriesFetcher::Size() const { return size_; } +size_t NumericField::EntriesFetcher::Size() const { return size_; } -std::unique_ptr Numeric::EntriesFetcher::Begin() { +std::unique_ptr NumericField::EntriesFetcher::Begin() { auto itr = std::make_unique( entries_range_, additional_entries_range_, untracked_keys_); itr->Next(); return itr; } -uint64_t Numeric::GetRecordCount() const { +uint64_t NumericField::GetRecordCount() const { absl::MutexLock lock(&index_mutex_); return tracked_keys_.size(); } diff --git a/src/indexes/numeric.h b/src/indexes/numeric.h index b83984a11..316a6709a 100644 --- a/src/indexes/numeric.h +++ b/src/indexes/numeric.h @@ -79,9 +79,9 @@ class BTreeNumeric { utils::SegmentTree segment_tree_; }; -class Numeric : public IndexBase { +class NumericField : public IndexBase { public: - explicit Numeric(const data_model::NumericIndex& numeric_index_proto); + explicit NumericField(const data_model::NumericIndex& numeric_index_proto); absl::StatusOr AddRecord(const InternedStringPtr& key, absl::string_view data) override ABSL_LOCKS_EXCLUDED(index_mutex_); @@ -126,7 +126,7 @@ class Numeric : public IndexBase { private: static bool NextKeys( - const Numeric::EntriesRange& range, + const NumericField::EntriesRange& range, BTreeNumericIndex::ConstIterator& iter, std::optional& keys_iter); const EntriesRange& entries_range_; diff --git a/src/indexes/tag.cc b/src/indexes/tag.cc index 16bb7669d..70bc15e99 100644 --- a/src/indexes/tag.cc +++ b/src/indexes/tag.cc @@ -39,14 +39,14 @@ static bool IsValidPrefix(absl::string_view str) { str[str.length() - 2] != '*'; } -Tag::Tag(const data_model::TagIndex& tag_index_proto) +TagField::TagField(const data_model::TagIndex& tag_index_proto) : IndexBase(IndexerType::kTag), separator_(tag_index_proto.separator()[0]), case_sensitive_(tag_index_proto.case_sensitive()), tree_(case_sensitive_) {} -absl::StatusOr Tag::AddRecord(const InternedStringPtr& key, - absl::string_view data) { +absl::StatusOr TagField::AddRecord(const InternedStringPtr& key, + absl::string_view data) { auto interned_data = StringInternStore::Intern(data); auto parsed_tags = ParseRecordTags(*interned_data, separator_); absl::MutexLock lock(&index_mutex_); @@ -68,7 +68,7 @@ absl::StatusOr Tag::AddRecord(const InternedStringPtr& key, return true; } -absl::StatusOr> Tag::ParseSearchTags( +absl::StatusOr> TagField::ParseSearchTags( absl::string_view data, char separator) { absl::flat_hash_set parsed_tags; std::vector parts = absl::StrSplit(data, separator); @@ -94,7 +94,7 @@ absl::StatusOr> Tag::ParseSearchTags( return parsed_tags; } -absl::flat_hash_set Tag::ParseRecordTags( +absl::flat_hash_set TagField::ParseRecordTags( absl::string_view data, char separator) { absl::flat_hash_set parsed_tags; for (const auto& part : absl::StrSplit(data, separator)) { @@ -106,8 +106,8 @@ absl::flat_hash_set Tag::ParseRecordTags( return parsed_tags; } -absl::StatusOr Tag::ModifyRecord(const InternedStringPtr& key, - absl::string_view data) { +absl::StatusOr TagField::ModifyRecord(const InternedStringPtr& key, + absl::string_view data) { // TODO: implement operator [] in patricia_tree. auto interned_data = StringInternStore::Intern(data); auto new_parsed_tags = ParseRecordTags(*interned_data, separator_); @@ -144,8 +144,8 @@ absl::StatusOr Tag::ModifyRecord(const InternedStringPtr& key, return true; } -absl::StatusOr Tag::RemoveRecord(const InternedStringPtr& key, - DeletionType deletion_type) { +absl::StatusOr TagField::RemoveRecord(const InternedStringPtr& key, + DeletionType deletion_type) { absl::MutexLock lock(&index_mutex_); if (deletion_type == DeletionType::kRecord) { // If key is DELETED, remove it from untracked_keys_. @@ -166,7 +166,7 @@ absl::StatusOr Tag::RemoveRecord(const InternedStringPtr& key, return true; } -int Tag::RespondWithInfo(ValkeyModuleCtx* ctx) const { +int TagField::RespondWithInfo(ValkeyModuleCtx* ctx) const { auto num_replies = 6; ValkeyModule_ReplyWithSimpleString(ctx, "type"); ValkeyModule_ReplyWithSimpleString(ctx, "TAG"); @@ -184,12 +184,12 @@ int Tag::RespondWithInfo(ValkeyModuleCtx* ctx) const { return num_replies; } -bool Tag::IsTracked(const InternedStringPtr& key) const { +bool TagField::IsTracked(const InternedStringPtr& key) const { absl::MutexLock lock(&index_mutex_); return tracked_tags_by_keys_.contains(key); } -std::unique_ptr Tag::ToProto() const { +std::unique_ptr TagField::ToProto() const { auto index_proto = std::make_unique(); auto tag_index = std::make_unique(); tag_index->set_separator(absl::string_view(&separator_, 1)); @@ -198,7 +198,7 @@ std::unique_ptr Tag::ToProto() const { return index_proto; } -InternedStringPtr Tag::GetRawValue(const InternedStringPtr& key) const { +InternedStringPtr TagField::GetRawValue(const InternedStringPtr& key) const { // Note that the Tag index is not mutated while the time sliced mutex is // in a read mode and therefor it is safe to skip lock acquiring. if (auto it = tracked_tags_by_keys_.find(key); @@ -208,7 +208,7 @@ InternedStringPtr Tag::GetRawValue(const InternedStringPtr& key) const { return nullptr; } -const absl::flat_hash_set* Tag::GetValue( +const absl::flat_hash_set* TagField::GetValue( const InternedStringPtr& key, bool& case_sensitive) const { // Note that the Tag index is not mutated while the time sliced mutex is // in a read mode and therefor it is safe to skip lock acquiring. @@ -220,7 +220,7 @@ const absl::flat_hash_set* Tag::GetValue( return nullptr; } -Tag::EntriesFetcherIterator::EntriesFetcherIterator( +TagField::EntriesFetcherIterator::EntriesFetcherIterator( const PatriciaTreeIndex& tree, absl::flat_hash_set& entries, const InternedStringSet& untracked_keys, bool negate) @@ -229,7 +229,7 @@ Tag::EntriesFetcherIterator::EntriesFetcherIterator( untracked_keys_(untracked_keys), negate_(negate) {} -bool Tag::EntriesFetcherIterator::Done() const { +bool TagField::EntriesFetcherIterator::Done() const { if (negate_) { return tree_iter_.Done() && (untracked_keys_.empty() || @@ -239,7 +239,7 @@ bool Tag::EntriesFetcherIterator::Done() const { return entries_.empty() && next_node_ == nullptr; } -void Tag::EntriesFetcherIterator::NextNegate() { +void TagField::EntriesFetcherIterator::NextNegate() { if (next_node_) { ++next_iter_; if (next_iter_ != next_node_->value.value().end()) { @@ -264,7 +264,7 @@ void Tag::EntriesFetcherIterator::NextNegate() { ++untracked_keys_iter_.value(); } -void Tag::EntriesFetcherIterator::Next() { +void TagField::EntriesFetcherIterator::Next() { if (negate_) { NextNegate(); return; @@ -287,7 +287,7 @@ void Tag::EntriesFetcherIterator::Next() { next_node_ = nullptr; } -const InternedStringPtr& Tag::EntriesFetcherIterator::operator*() const { +const InternedStringPtr& TagField::EntriesFetcherIterator::operator*() const { if (negate_ && tree_iter_.Done()) { return *untracked_keys_iter_.value(); } @@ -295,7 +295,7 @@ const InternedStringPtr& Tag::EntriesFetcherIterator::operator*() const { } // TODO: b/357027854 - Support Suffix/Infix Search -std::unique_ptr Tag::Search( +std::unique_ptr TagField::Search( const query::TagPredicate& predicate, bool negate) const { absl::flat_hash_set entries; size_t size = 0; @@ -329,20 +329,20 @@ std::unique_ptr Tag::Search( : tracked_tags_by_keys_.size(); size += untracked_keys_.size(); } - return std::make_unique(tree_, entries, size, negate, - untracked_keys_); + return std::make_unique(tree_, entries, size, negate, + untracked_keys_); } -std::unique_ptr Tag::EntriesFetcher::Begin() { +std::unique_ptr TagField::EntriesFetcher::Begin() { auto itr = std::make_unique(tree_, entries_, untracked_keys_, negate_); itr->Next(); return itr; } -size_t Tag::EntriesFetcher::Size() const { return size_; } +size_t TagField::EntriesFetcher::Size() const { return size_; } -uint64_t Tag::GetRecordCount() const { +uint64_t TagField::GetRecordCount() const { absl::MutexLock lock(&index_mutex_); return tracked_tags_by_keys_.size(); } diff --git a/src/indexes/tag.h b/src/indexes/tag.h index 72e8aec44..47607f54d 100644 --- a/src/indexes/tag.h +++ b/src/indexes/tag.h @@ -29,9 +29,9 @@ namespace valkey_search::indexes { -class Tag : public IndexBase { +class TagField : public IndexBase { public: - explicit Tag(const data_model::TagIndex& tag_index_proto); + explicit TagField(const data_model::TagIndex& tag_index_proto); absl::StatusOr AddRecord(const InternedStringPtr& key, absl::string_view data) override ABSL_LOCKS_EXCLUDED(index_mutex_); diff --git a/src/indexes/text.h b/src/indexes/text.h index d4f89b7ad..f5069b227 100644 --- a/src/indexes/text.h +++ b/src/indexes/text.h @@ -34,9 +34,9 @@ namespace valkey_search::indexes { -class Text : public IndexBase { +class TextField : public IndexBase { public: - explicit Text(const data_model::TextIndex& text_index_proto); + explicit TextField(const data_model::TextIndex& text_index_proto); absl::StatusOr AddRecord(const InternedStringPtr& key, absl::string_view data) override ABSL_LOCKS_EXCLUDED(index_mutex_); diff --git a/src/indexes/vector_base.cc b/src/indexes/vector_base.cc index f2fef524f..d2b27a348 100644 --- a/src/indexes/vector_base.cc +++ b/src/indexes/vector_base.cc @@ -128,9 +128,9 @@ std::vector NormalizeEmbedding(absl::string_view record, size_t type_size, } template -void VectorBase::Init(int dimensions, - valkey_search::data_model::DistanceMetric distance_metric, - std::unique_ptr> &space) { +void VectorBaseField::Init(int dimensions, + valkey_search::data_model::DistanceMetric distance_metric, + std::unique_ptr> &space) { space = CreateSpace(dimensions, distance_metric); distance_metric_ = distance_metric; if (distance_metric == @@ -139,7 +139,7 @@ void VectorBase::Init(int dimensions, } } -std::shared_ptr VectorBase::InternVector( +std::shared_ptr VectorBaseField::InternVector( absl::string_view record, std::optional &magnitude) { if (!IsValidSizeVector(record)) { return nullptr; @@ -155,8 +155,8 @@ std::shared_ptr VectorBase::InternVector( return StringInternStore::Intern(record, vector_allocator_.get()); } -absl::StatusOr VectorBase::AddRecord(const InternedStringPtr &key, - absl::string_view record) { +absl::StatusOr VectorBaseField::AddRecord(const InternedStringPtr &key, + absl::string_view record) { std::optional magnitude; auto interned_vector = InternVector(record, magnitude); if (!interned_vector) { @@ -179,7 +179,7 @@ absl::StatusOr VectorBase::AddRecord(const InternedStringPtr &key, return true; } -absl::StatusOr VectorBase::GetInternalId( +absl::StatusOr VectorBaseField::GetInternalId( const InternedStringPtr &key) const { absl::ReaderMutexLock lock(&key_to_metadata_mutex_); auto it = tracked_metadata_by_key_.find(key); @@ -189,7 +189,7 @@ absl::StatusOr VectorBase::GetInternalId( return it->second.internal_id; } -absl::StatusOr VectorBase::GetInternalIdDuringSearch( +absl::StatusOr VectorBaseField::GetInternalIdDuringSearch( const InternedStringPtr &key) const { auto it = tracked_metadata_by_key_.find(key); if (it == tracked_metadata_by_key_.end()) { @@ -198,7 +198,7 @@ absl::StatusOr VectorBase::GetInternalIdDuringSearch( return it->second.internal_id; } -absl::StatusOr VectorBase::GetKeyDuringSearch( +absl::StatusOr VectorBaseField::GetKeyDuringSearch( uint64_t internal_id) const { auto it = key_by_internal_id_.find(internal_id); if (it == key_by_internal_id_.end()) { @@ -207,8 +207,8 @@ absl::StatusOr VectorBase::GetKeyDuringSearch( return it->second; } -absl::StatusOr VectorBase::ModifyRecord(const InternedStringPtr &key, - absl::string_view record) { +absl::StatusOr VectorBaseField::ModifyRecord(const InternedStringPtr &key, + absl::string_view record) { // VectorExternalizer tracks added entries. We need to untrack mutations which // are processed as modified records. std::optional magnitude; @@ -240,7 +240,7 @@ absl::StatusOr VectorBase::ModifyRecord(const InternedStringPtr &key, } template -absl::StatusOr> VectorBase::CreateReply( +absl::StatusOr> VectorBaseField::CreateReply( std::priority_queue> &knn_res) { std::deque ret; while (!knn_res.empty()) { @@ -257,7 +257,7 @@ absl::StatusOr> VectorBase::CreateReply( return ret; } -absl::StatusOr> VectorBase::GetValue( +absl::StatusOr> VectorBaseField::GetValue( const InternedStringPtr &key) const { auto it = tracked_metadata_by_key_.find(key); if (it == tracked_metadata_by_key_.end()) { @@ -277,13 +277,13 @@ absl::StatusOr> VectorBase::GetValue( return result; } -bool VectorBase::IsTracked(const InternedStringPtr &key) const { +bool VectorBaseField::IsTracked(const InternedStringPtr &key) const { absl::ReaderMutexLock lock(&key_to_metadata_mutex_); auto it = tracked_metadata_by_key_.find(key); return (it != tracked_metadata_by_key_.end()); } -absl::StatusOr VectorBase::RemoveRecord( +absl::StatusOr VectorBaseField::RemoveRecord( const InternedStringPtr &key, [[maybe_unused]] indexes::DeletionType deletion_type) { VMSDK_ASSIGN_OR_RETURN(auto res, UnTrackKey(key)); @@ -294,7 +294,7 @@ absl::StatusOr VectorBase::RemoveRecord( return true; } -absl::StatusOr> VectorBase::UnTrackKey( +absl::StatusOr> VectorBaseField::UnTrackKey( const InternedStringPtr &key) { if (key->Str().empty()) { return std::nullopt; @@ -317,14 +317,14 @@ absl::StatusOr> VectorBase::UnTrackKey( return id; } -char *VectorBase::TrackVector(uint64_t internal_id, char *vector, size_t len) { +char *VectorBaseField::TrackVector(uint64_t internal_id, char *vector, size_t len) { auto interned_vector = StringInternStore::Intern( absl::string_view(vector, len), vector_allocator_.get()); TrackVector(internal_id, interned_vector); return (char *)interned_vector->Str().data(); } -absl::StatusOr VectorBase::TrackKey(const InternedStringPtr &key, +absl::StatusOr VectorBaseField::TrackKey(const InternedStringPtr &key, float magnitude, const InternedStringPtr &vector) { if (key->Str().empty()) { @@ -346,7 +346,7 @@ absl::StatusOr VectorBase::TrackKey(const InternedStringPtr &key, // Return an error if the key is empty or not being tracked. // Return false if the tracked vector matches the input vector. // Otherwise, track the new vector and return true. -absl::StatusOr VectorBase::UpdateMetadata( +absl::StatusOr VectorBaseField::UpdateMetadata( const InternedStringPtr &key, float magnitude, const InternedStringPtr &vector) { if (key->Str().empty()) { @@ -370,7 +370,7 @@ absl::StatusOr VectorBase::UpdateMetadata( return true; } -int VectorBase::RespondWithInfo(ValkeyModuleCtx *ctx) const { +int VectorBaseField::RespondWithInfo(ValkeyModuleCtx *ctx) const { ValkeyModule_ReplyWithSimpleString(ctx, "type"); ValkeyModule_ReplyWithSimpleString(ctx, "VECTOR"); ValkeyModule_ReplyWithSimpleString(ctx, "index"); @@ -396,12 +396,12 @@ int VectorBase::RespondWithInfo(ValkeyModuleCtx *ctx) const { return 4; } -absl::Status VectorBase::SaveIndex(RDBChunkOutputStream chunked_out) const { +absl::Status VectorBaseField::SaveIndex(RDBChunkOutputStream chunked_out) const { VMSDK_RETURN_IF_ERROR(SaveIndexImpl(std::move(chunked_out))); return absl::OkStatus(); } -absl::Status VectorBase::SaveTrackedKeys( +absl::Status VectorBaseField::SaveTrackedKeys( RDBChunkOutputStream chunked_out) const { absl::ReaderMutexLock lock(&key_to_metadata_mutex_); for (const auto &[key, metadata] : tracked_metadata_by_key_) { @@ -417,7 +417,7 @@ absl::Status VectorBase::SaveTrackedKeys( return absl::OkStatus(); } -void VectorBase::ExternalizeVector(ValkeyModuleCtx *ctx, +void VectorBaseField::ExternalizeVector(ValkeyModuleCtx *ctx, const AttributeDataType *attribute_data_type, absl::string_view key_cstr, absl::string_view attribute_identifier) { @@ -443,7 +443,7 @@ void VectorBase::ExternalizeVector(ValkeyModuleCtx *ctx, } } -absl::Status VectorBase::LoadTrackedKeys( +absl::Status VectorBaseField::LoadTrackedKeys( ValkeyModuleCtx *ctx, const AttributeDataType *attribute_data_type, SupplementalContentChunkIter &&iter) { absl::WriterMutexLock lock(&key_to_metadata_mutex_); @@ -470,7 +470,7 @@ absl::Status VectorBase::LoadTrackedKeys( return absl::OkStatus(); } -std::unique_ptr VectorBase::ToProto() const { +std::unique_ptr VectorBaseField::ToProto() const { absl::ReaderMutexLock lock(&key_to_metadata_mutex_); auto index_proto = std::make_unique(); auto vector_index = std::make_unique(); @@ -484,13 +484,13 @@ std::unique_ptr VectorBase::ToProto() const { } absl::StatusOr> -VectorBase::ComputeDistanceFromRecord(const InternedStringPtr &key, +VectorBaseField::ComputeDistanceFromRecord(const InternedStringPtr &key, absl::string_view query) const { VMSDK_ASSIGN_OR_RETURN(auto internal_id, GetInternalIdDuringSearch(key)); return ComputeDistanceFromRecordImpl(internal_id, query); } -void VectorBase::AddPrefilteredKey( +void VectorBaseField::AddPrefilteredKey( absl::string_view query, uint64_t count, const InternedStringPtr &key, std::priority_queue> &results, absl::flat_hash_set &top_keys) const { @@ -510,7 +510,7 @@ void VectorBase::AddPrefilteredKey( } } -vmsdk::UniqueValkeyString VectorBase::NormalizeStringRecord( +vmsdk::UniqueValkeyString VectorBaseField::NormalizeStringRecord( vmsdk::UniqueValkeyString record) const { CHECK_EQ(GetDataTypeSize(), sizeof(float)); auto record_str = vmsdk::ToStringView(record.get()); @@ -531,16 +531,16 @@ vmsdk::UniqueValkeyString VectorBase::NormalizeStringRecord( return vmsdk::MakeUniqueValkeyString(binary_string); } -uint64_t VectorBase::GetRecordCount() const { +uint64_t VectorBaseField::GetRecordCount() const { absl::ReaderMutexLock lock(&key_to_metadata_mutex_); return key_by_internal_id_.size(); } -template void VectorBase::Init( +template void VectorBaseField::Init( int dimensions, data_model::DistanceMetric distance_metric, std::unique_ptr> &space); -template absl::StatusOr> VectorBase::CreateReply( +template absl::StatusOr> VectorBaseField::CreateReply( std::priority_queue> &knn_res); } // namespace indexes diff --git a/src/indexes/vector_base.h b/src/indexes/vector_base.h index a15af9be4..9283b24d8 100644 --- a/src/indexes/vector_base.h +++ b/src/indexes/vector_base.h @@ -101,7 +101,7 @@ absl::string_view LookupKeyByValue( } } -class VectorBase : public IndexBase, public hnswlib::VectorTracker { +class VectorBaseField : public IndexBase, public hnswlib::VectorTracker { public: absl::StatusOr AddRecord(const InternedStringPtr& key, absl::string_view record) override; @@ -148,9 +148,9 @@ class VectorBase : public IndexBase, public hnswlib::VectorTracker { std::optional& magnitude); protected: - VectorBase(IndexerType indexer_type, int dimensions, - data_model::AttributeDataType attribute_data_type, - absl::string_view attribute_identifier) + VectorBaseField(IndexerType indexer_type, int dimensions, + data_model::AttributeDataType attribute_data_type, + absl::string_view attribute_identifier) : IndexBase(indexer_type), dimensions_(dimensions), attribute_identifier_(attribute_identifier), diff --git a/src/indexes/vector_flat.cc b/src/indexes/vector_flat.cc index c8091d53b..5ab857f05 100644 --- a/src/indexes/vector_flat.cc +++ b/src/indexes/vector_flat.cc @@ -50,13 +50,13 @@ namespace valkey_search::indexes { template -absl::StatusOr>> VectorFlat::Create( +absl::StatusOr>> VectorFlatField::Create( const data_model::VectorIndex &vector_index_proto, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) { try { - auto index = std::shared_ptr>( - new VectorFlat(vector_index_proto.dimension_count(), + auto index = std::shared_ptr>( + new VectorFlatField(vector_index_proto.dimension_count(), vector_index_proto.distance_metric(), vector_index_proto.flat_algorithm().block_size(), attribute_identifier, attribute_data_type)); @@ -73,14 +73,14 @@ absl::StatusOr>> VectorFlat::Create( } template -void VectorFlat::TrackVector(uint64_t internal_id, +void VectorFlatField::TrackVector(uint64_t internal_id, const InternedStringPtr &vector) { absl::MutexLock lock(&tracked_vectors_mutex_); tracked_vectors_[internal_id] = vector; } template -bool VectorFlat::IsVectorMatch(uint64_t internal_id, +bool VectorFlatField::IsVectorMatch(uint64_t internal_id, const InternedStringPtr &vector) { absl::MutexLock lock(&tracked_vectors_mutex_); auto it = tracked_vectors_.find(internal_id); @@ -91,19 +91,19 @@ bool VectorFlat::IsVectorMatch(uint64_t internal_id, } template -void VectorFlat::UnTrackVector(uint64_t internal_id) { +void VectorFlatField::UnTrackVector(uint64_t internal_id) { absl::MutexLock lock(&tracked_vectors_mutex_); tracked_vectors_.erase(internal_id); } template -absl::StatusOr>> VectorFlat::LoadFromRDB( +absl::StatusOr>> VectorFlatField::LoadFromRDB( ValkeyModuleCtx *ctx, const AttributeDataType *attribute_data_type, const data_model::VectorIndex &vector_index_proto, absl::string_view attribute_identifier, SupplementalContentChunkIter &&iter) { try { - auto index = std::shared_ptr>(new VectorFlat( + auto index = std::shared_ptr>(new VectorFlatField( vector_index_proto.dimension_count(), vector_index_proto.distance_metric(), vector_index_proto.flat_algorithm().block_size(), attribute_identifier, @@ -124,16 +124,16 @@ absl::StatusOr>> VectorFlat::LoadFromRDB( } template -VectorFlat::VectorFlat( +VectorFlatField::VectorFlatField( int dimensions, valkey_search::data_model::DistanceMetric distance_metric, uint32_t block_size, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) - : VectorBase(IndexerType::kFlat, dimensions, attribute_data_type, - attribute_identifier), + : VectorBaseField(IndexerType::kFlat, dimensions, attribute_data_type, + attribute_identifier), block_size_(block_size) {} template -absl::Status VectorFlat::ResizeIfFull() { +absl::Status VectorFlatField::ResizeIfFull() { { absl::ReaderMutexLock lock(&resize_mutex_); if (algo_->cur_element_count_ < GetCapacity()) { @@ -152,7 +152,7 @@ absl::Status VectorFlat::ResizeIfFull() { } template -absl::Status VectorFlat::AddRecordImpl(uint64_t internal_id, +absl::Status VectorFlatField::AddRecordImpl(uint64_t internal_id, absl::string_view record) { do { try { @@ -176,7 +176,7 @@ absl::Status VectorFlat::AddRecordImpl(uint64_t internal_id, } template -absl::Status VectorFlat::ModifyRecordImpl(uint64_t internal_id, +absl::Status VectorFlatField::ModifyRecordImpl(uint64_t internal_id, absl::string_view record) { absl::ReaderMutexLock lock(&resize_mutex_); std::unique_lock index_lock(algo_->index_lock); @@ -193,7 +193,7 @@ absl::Status VectorFlat::ModifyRecordImpl(uint64_t internal_id, return absl::OkStatus(); } template -absl::Status VectorFlat::RemoveRecordImpl(uint64_t internal_id) { +absl::Status VectorFlatField::RemoveRecordImpl(uint64_t internal_id) { try { absl::ReaderMutexLock lock(&resize_mutex_); algo_->removePoint(internal_id); @@ -221,7 +221,7 @@ class CancelCondition : public hnswlib::BaseCancellationFunctor { template -absl::StatusOr> VectorFlat::Search( +absl::StatusOr> VectorFlatField::Search( absl::string_view query, uint64_t count, cancel::Token &cancellation_token, std::unique_ptr filter) { @@ -261,7 +261,7 @@ absl::StatusOr> VectorFlat::Search( template absl::StatusOr> -VectorFlat::ComputeDistanceFromRecordImpl(uint64_t internal_id, +VectorFlatField::ComputeDistanceFromRecordImpl(uint64_t internal_id, absl::string_view query) const { absl::ReaderMutexLock lock(&resize_mutex_); auto search = algo_->dict_external_to_internal.find(internal_id); @@ -277,7 +277,7 @@ VectorFlat::ComputeDistanceFromRecordImpl(uint64_t internal_id, } template -void VectorFlat::ToProtoImpl( +void VectorFlatField::ToProtoImpl( data_model::VectorIndex *vector_index_proto) const { data_model::VectorDataType data_type; if constexpr (std::is_same_v) { @@ -295,7 +295,7 @@ void VectorFlat::ToProtoImpl( } template -int VectorFlat::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { +int VectorFlatField::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { ValkeyModule_ReplyWithSimpleString(ctx, "data_type"); if constexpr (std::is_same_v) { ValkeyModule_ReplyWithSimpleString( @@ -321,12 +321,12 @@ int VectorFlat::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { } template -absl::Status VectorFlat::SaveIndexImpl( +absl::Status VectorFlatField::SaveIndexImpl( RDBChunkOutputStream chunked_out) const { absl::ReaderMutexLock lock(&resize_mutex_); return algo_->SaveIndex(chunked_out); } -template class VectorFlat; +template class VectorFlatField; } // namespace valkey_search::indexes diff --git a/src/indexes/vector_flat.h b/src/indexes/vector_flat.h index 97181f1ed..17e177261 100644 --- a/src/indexes/vector_flat.h +++ b/src/indexes/vector_flat.h @@ -32,19 +32,19 @@ namespace valkey_search::indexes { template -class VectorFlat : public VectorBase { +class VectorFlatField : public VectorBaseField { public: - static absl::StatusOr>> Create( + static absl::StatusOr>> Create( const data_model::VectorIndex& vector_index_proto, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) ABSL_NO_THREAD_SAFETY_ANALYSIS; - static absl::StatusOr>> LoadFromRDB( + static absl::StatusOr>> LoadFromRDB( ValkeyModuleCtx* ctx, const AttributeDataType* attribute_data_type, const data_model::VectorIndex& vector_index_proto, absl::string_view attribute_identifier, SupplementalContentChunkIter&& iter) ABSL_NO_THREAD_SAFETY_ANALYSIS; - ~VectorFlat() override = default; + ~VectorFlatField() override = default; size_t GetDataTypeSize() const override { return sizeof(T); } const hnswlib::SpaceInterface* GetSpace() const { @@ -93,9 +93,9 @@ class VectorFlat : public VectorBase { ABSL_LOCKS_EXCLUDED(tracked_vectors_mutex_); private: - VectorFlat(int dimensions, data_model::DistanceMetric distance_metric, - uint32_t block_size, absl::string_view attribute_identifier, - data_model::AttributeDataType attribute_data_type); + VectorFlatField(int dimensions, data_model::DistanceMetric distance_metric, + uint32_t block_size, absl::string_view attribute_identifier, + data_model::AttributeDataType attribute_data_type); std::unique_ptr> algo_ ABSL_GUARDED_BY(resize_mutex_); std::unique_ptr> space_; diff --git a/src/indexes/vector_hnsw.cc b/src/indexes/vector_hnsw.cc index 12382ca50..c93d8050f 100644 --- a/src/indexes/vector_hnsw.cc +++ b/src/indexes/vector_hnsw.cc @@ -80,13 +80,13 @@ std::optional GetInternalIdDuringSearch( namespace valkey_search::indexes { template -absl::StatusOr>> VectorHNSW::Create( +absl::StatusOr>> VectorHNSWField::Create( const data_model::VectorIndex &vector_index_proto, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) { try { - auto index = std::shared_ptr>( - new VectorHNSW(vector_index_proto.dimension_count(), + auto index = std::shared_ptr>( + new VectorHNSWField(vector_index_proto.dimension_count(), attribute_identifier, attribute_data_type)); index->Init(vector_index_proto.dimension_count(), vector_index_proto.distance_metric(), index->space_); @@ -108,14 +108,14 @@ absl::StatusOr>> VectorHNSW::Create( } template -void VectorHNSW::TrackVector(uint64_t internal_id, +void VectorHNSWField::TrackVector(uint64_t internal_id, const InternedStringPtr &vector) { absl::MutexLock lock(&tracked_vectors_mutex_); tracked_vectors_.push_back(vector); } template -bool VectorHNSW::IsVectorMatch(uint64_t internal_id, +bool VectorHNSWField::IsVectorMatch(uint64_t internal_id, const InternedStringPtr &vector) { absl::ReaderMutexLock lock(&resize_mutex_); { @@ -134,16 +134,16 @@ bool VectorHNSW::IsVectorMatch(uint64_t internal_id, // UnTrackVector does not delete the vector in VectorHNSW, as vectors are never // physically removed from the graph—only marked as deleted. template -void VectorHNSW::UnTrackVector(uint64_t internal_id) {} +void VectorHNSWField::UnTrackVector(uint64_t internal_id) {} template -absl::StatusOr>> VectorHNSW::LoadFromRDB( +absl::StatusOr>> VectorHNSWField::LoadFromRDB( ValkeyModuleCtx *ctx, const AttributeDataType *attribute_data_type, const data_model::VectorIndex &vector_index_proto, absl::string_view attribute_identifier, SupplementalContentChunkIter &&iter) { try { - auto index = std::shared_ptr>(new VectorHNSW( + auto index = std::shared_ptr>(new VectorHNSWField( vector_index_proto.dimension_count(), attribute_identifier, attribute_data_type->ToProto())); index->Init(vector_index_proto.dimension_count(), @@ -173,14 +173,14 @@ absl::StatusOr>> VectorHNSW::LoadFromRDB( } template -VectorHNSW::VectorHNSW(int dimensions, +VectorHNSWField::VectorHNSWField(int dimensions, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) - : VectorBase(IndexerType::kHNSW, dimensions, attribute_data_type, - attribute_identifier) {} + : VectorBaseField(IndexerType::kHNSW, dimensions, attribute_data_type, + attribute_identifier) {} template -absl::Status VectorHNSW::AddRecordImpl(uint64_t internal_id, +absl::Status VectorHNSWField::AddRecordImpl(uint64_t internal_id, absl::string_view record) { do { try { @@ -204,7 +204,7 @@ absl::Status VectorHNSW::AddRecordImpl(uint64_t internal_id, } template -int VectorHNSW::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { +int VectorHNSWField::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { ValkeyModule_ReplyWithSimpleString(ctx, "data_type"); if constexpr (std::is_same_v) { ValkeyModule_ReplyWithSimpleString( @@ -234,14 +234,14 @@ int VectorHNSW::RespondWithInfoImpl(ValkeyModuleCtx *ctx) const { } template -absl::Status VectorHNSW::SaveIndexImpl( +absl::Status VectorHNSWField::SaveIndexImpl( RDBChunkOutputStream chunked_out) const { absl::ReaderMutexLock lock(&resize_mutex_); return algo_->SaveIndex(chunked_out); } template -absl::Status VectorHNSW::ResizeIfFull() { +absl::Status VectorHNSWField::ResizeIfFull() { { absl::ReaderMutexLock lock(&resize_mutex_); if (algo_->getCurrentElementCount() < algo_->getMaxElements() || @@ -276,7 +276,7 @@ absl::Status VectorHNSW::ResizeIfFull() { } template -absl::Status VectorHNSW::ModifyRecordImpl(uint64_t internal_id, +absl::Status VectorHNSWField::ModifyRecordImpl(uint64_t internal_id, absl::string_view record) { try { absl::ReaderMutexLock lock(&resize_mutex_); @@ -294,7 +294,7 @@ absl::Status VectorHNSW::ModifyRecordImpl(uint64_t internal_id, } template -absl::Status VectorHNSW::RemoveRecordImpl(uint64_t internal_id) { +absl::Status VectorHNSWField::RemoveRecordImpl(uint64_t internal_id) { try { absl::ReaderMutexLock lock(&resize_mutex_); algo_->markDelete(internal_id); @@ -319,7 +319,7 @@ class CancelCondition : public hnswlib::BaseCancellationFunctor { }; template -absl::StatusOr> VectorHNSW::Search( +absl::StatusOr> VectorHNSWField::Search( absl::string_view query, uint64_t count, cancel::Token& cancellation_token, std::unique_ptr filter, @@ -362,7 +362,7 @@ absl::StatusOr> VectorHNSW::Search( } template -void VectorHNSW::ToProtoImpl( +void VectorHNSWField::ToProtoImpl( data_model::VectorIndex *vector_index_proto) const { data_model::VectorDataType data_type; if constexpr (std::is_same_v) { @@ -383,7 +383,7 @@ void VectorHNSW::ToProtoImpl( template absl::StatusOr> -VectorHNSW::ComputeDistanceFromRecordImpl(uint64_t internal_id, +VectorHNSWField::ComputeDistanceFromRecordImpl(uint64_t internal_id, absl::string_view query) const { auto id = hnswlib_helpers::GetInternalIdDuringSearch(algo_.get(), internal_id); @@ -397,6 +397,6 @@ VectorHNSW::ComputeDistanceFromRecordImpl(uint64_t internal_id, internal_id}; } -template class VectorHNSW; +template class VectorHNSWField; } // namespace valkey_search::indexes diff --git a/src/indexes/vector_hnsw.h b/src/indexes/vector_hnsw.h index 2bb179be0..e6c3e31f0 100644 --- a/src/indexes/vector_hnsw.h +++ b/src/indexes/vector_hnsw.h @@ -31,19 +31,19 @@ namespace valkey_search::indexes { template -class VectorHNSW : public VectorBase { +class VectorHNSWField : public VectorBaseField { public: - static absl::StatusOr>> Create( + static absl::StatusOr>> Create( const data_model::VectorIndex& vector_index_proto, absl::string_view attribute_identifier, data_model::AttributeDataType attribute_data_type) ABSL_NO_THREAD_SAFETY_ANALYSIS; - static absl::StatusOr>> LoadFromRDB( + static absl::StatusOr>> LoadFromRDB( ValkeyModuleCtx* ctx, const AttributeDataType* attribute_data_type, const data_model::VectorIndex& vector_index_proto, absl::string_view attribute_identifier, SupplementalContentChunkIter&& iter) ABSL_NO_THREAD_SAFETY_ANALYSIS; - ~VectorHNSW() override = default; + ~VectorHNSWField() override = default; size_t GetDataTypeSize() const override { return sizeof(T); } const hnswlib::SpaceInterface* GetSpace() const { @@ -103,8 +103,8 @@ class VectorHNSW : public VectorBase { ABSL_LOCKS_EXCLUDED(tracked_vectors_mutex_); private: - VectorHNSW(int dimensions, absl::string_view attribute_identifier, - data_model::AttributeDataType attribute_data_type); + VectorHNSWField(int dimensions, absl::string_view attribute_identifier, + data_model::AttributeDataType attribute_data_type); std::unique_ptr> algo_ ABSL_GUARDED_BY(resize_mutex_); std::unique_ptr> space_; diff --git a/src/query/planner.cc b/src/query/planner.cc index 5fff1b305..1cbe1e0e7 100644 --- a/src/query/planner.cc +++ b/src/query/planner.cc @@ -19,7 +19,7 @@ constexpr double kPreFilteringThresholdRatio = 0.001; // 0.1% // The query planner decides whether to use pre or inline filtering based on // heuristics. bool UsePreFiltering(size_t estimated_num_of_keys, - indexes::VectorBase *vector_index) { + indexes::VectorBaseField *vector_index) { if (vector_index->GetIndexerType() == indexes::IndexerType::kFlat) { /* With a flat index, the search needs to go through all the vectors, taking O(N*log(k)). With pre-filtering, we can do the same search on the diff --git a/src/query/planner.h b/src/query/planner.h index a6f38442b..3865b3551 100644 --- a/src/query/planner.h +++ b/src/query/planner.h @@ -15,7 +15,7 @@ namespace valkey_search::query { // Returns whether to use pre-filtering as opposed to inline filtering based on // heuristics. bool UsePreFiltering(size_t estimated_num_of_keys, - indexes::VectorBase *vector_index); + indexes::VectorBaseField *vector_index); } // namespace valkey_search::query #endif // VALKEYSEARCH_SRC_QUERY_PLANNER_H_ diff --git a/src/query/predicate.cc b/src/query/predicate.cc index 35e55fbd7..c086931aa 100644 --- a/src/query/predicate.cc +++ b/src/query/predicate.cc @@ -25,7 +25,7 @@ bool NegatePredicate::Evaluate(Evaluator& evaluator) const { return !predicate_->Evaluate(evaluator); } -NumericPredicate::NumericPredicate(const indexes::Numeric* index, +NumericPredicate::NumericPredicate(const indexes::NumericField* index, absl::string_view alias, absl::string_view identifier, double start, bool is_inclusive_start, double end, @@ -52,7 +52,7 @@ bool NumericPredicate::Evaluate(const double* value) const { (is_inclusive_end_ && *value == end_)); } -TagPredicate::TagPredicate(const indexes::Tag* index, absl::string_view alias, +TagPredicate::TagPredicate(const indexes::TagField* index, absl::string_view alias, absl::string_view identifier, absl::string_view raw_tag_string, const absl::flat_hash_set& tags) diff --git a/src/query/predicate.h b/src/query/predicate.h index 08da53c77..989d63c9b 100644 --- a/src/query/predicate.h +++ b/src/query/predicate.h @@ -19,8 +19,8 @@ #include "vmsdk/src/type_conversions.h" namespace valkey_search::indexes { -class Numeric; -class Tag; +class NumericField; +class TagField; } // namespace valkey_search::indexes namespace valkey_search::query { @@ -73,10 +73,10 @@ class NegatePredicate : public Predicate { class NumericPredicate : public Predicate { public: - NumericPredicate(const indexes::Numeric* index, absl::string_view alias, + NumericPredicate(const indexes::NumericField* index, absl::string_view alias, absl::string_view identifier, double start, bool is_inclusive_start, double end, bool is_inclusive_end); - const indexes::Numeric* GetIndex() const { return index_; } + const indexes::NumericField* GetIndex() const { return index_; } absl::string_view GetIdentifier() const { return vmsdk::ToStringView(identifier_.get()); } @@ -92,7 +92,7 @@ class NumericPredicate : public Predicate { bool Evaluate(const double* value) const; private: - const indexes::Numeric* index_; + const indexes::NumericField* index_; std::string alias_; vmsdk::UniqueValkeyString identifier_; double start_; @@ -103,13 +103,13 @@ class NumericPredicate : public Predicate { class TagPredicate : public Predicate { public: - TagPredicate(const indexes::Tag* index, absl::string_view alias, + TagPredicate(const indexes::TagField* index, absl::string_view alias, absl::string_view identifier, absl::string_view raw_tag_string, const absl::flat_hash_set& tags); bool Evaluate(Evaluator& evaluator) const override; bool Evaluate(const absl::flat_hash_set* tags, bool case_sensitive) const; - const indexes::Tag* GetIndex() const { return index_; } + const indexes::TagField* GetIndex() const { return index_; } absl::string_view GetAlias() const { return alias_; } absl::string_view GetIdentifier() const { return vmsdk::ToStringView(identifier_.get()); @@ -121,7 +121,7 @@ class TagPredicate : public Predicate { const absl::flat_hash_set& GetTags() const { return tags_; } private: - const indexes::Tag* index_; + const indexes::TagField* index_; vmsdk::UniqueValkeyString identifier_; std::string alias_; std::string raw_tag_string_; diff --git a/src/query/response_generator.cc b/src/query/response_generator.cc index 2bac242c7..6df6f36a0 100644 --- a/src/query/response_generator.cc +++ b/src/query/response_generator.cc @@ -87,7 +87,7 @@ class PredicateEvaluator : public query::Evaluator { return false; } auto index = predicate.GetIndex(); - auto tags = indexes::Tag::ParseSearchTags( + auto tags = indexes::TagField::ParseSearchTags( vmsdk::ToStringView(it->second.value.get()), index->GetSeparator()); if (!tags.ok()) { return false; diff --git a/src/query/search.cc b/src/query/search.cc index 872c39a22..95cab1e39 100644 --- a/src/query/search.cc +++ b/src/query/search.cc @@ -47,7 +47,7 @@ namespace valkey_search::query { class InlineVectorFilter : public hnswlib::BaseFilterFunctor { public: InlineVectorFilter(query::Predicate *filter_predicate, - indexes::VectorBase *vector_index) + indexes::VectorBaseField *vector_index) : filter_predicate_(filter_predicate), vector_index_(vector_index) {} ~InlineVectorFilter() override = default; @@ -62,10 +62,10 @@ class InlineVectorFilter : public hnswlib::BaseFilterFunctor { private: query::Predicate *filter_predicate_; - indexes::VectorBase *vector_index_; + indexes::VectorBaseField *vector_index_; }; absl::StatusOr> PerformVectorSearch( - indexes::VectorBase *vector_index, + indexes::VectorBaseField *vector_index, const VectorSearchParameters ¶meters) { std::unique_ptr inline_filter; if (parameters.filter_parse_results.root_predicate != nullptr) { @@ -74,7 +74,7 @@ absl::StatusOr> PerformVectorSearch( VMSDK_LOG(DEBUG, nullptr) << "Performing vector search with inline filter"; } if (vector_index->GetIndexerType() == indexes::IndexerType::kHNSW) { - auto vector_hnsw = dynamic_cast *>(vector_index); + auto vector_hnsw = dynamic_cast *>(vector_index); auto latency_sample = SAMPLE_EVERY_N(100); auto res = vector_hnsw->Search(parameters.query, parameters.k, @@ -85,7 +85,7 @@ absl::StatusOr> PerformVectorSearch( return res; } if (vector_index->GetIndexerType() == indexes::IndexerType::kFlat) { - auto vector_flat = dynamic_cast *>(vector_index); + auto vector_flat = dynamic_cast *>(vector_index); auto latency_sample = SAMPLE_EVERY_N(100); auto res = vector_flat->Search(parameters.query, parameters.k, parameters.cancellation_token, @@ -184,7 +184,7 @@ std::priority_queue> CalcBestMatchingPrefilteredKeys( const VectorSearchParameters ¶meters, std::queue> &entries_fetchers, - indexes::VectorBase *vector_index) { + indexes::VectorBaseField *vector_index) { std::priority_queue> results; absl::flat_hash_set top_keys; auto predicate = parameters.filter_parse_results.root_predicate.get(); @@ -262,7 +262,7 @@ absl::StatusOr> MaybeAddIndexedContent( vmsdk::UniqueValkeyString attribute_value = nullptr; switch (attribute_info.index->GetIndexerType()) { case indexes::IndexerType::kTag: { - auto tag_index = dynamic_cast(attribute_info.index); + auto tag_index = dynamic_cast(attribute_info.index); auto tag_value_ptr = tag_index->GetRawValue(neighbor.external_id); if (tag_value_ptr != nullptr) { attribute_value = vmsdk::MakeUniqueValkeyString(*tag_value_ptr); @@ -271,7 +271,7 @@ absl::StatusOr> MaybeAddIndexedContent( } case indexes::IndexerType::kNumeric: { auto numeric_index = - dynamic_cast(attribute_info.index); + dynamic_cast(attribute_info.index); auto numeric = numeric_index->GetValue(neighbor.external_id); if (numeric != nullptr) { attribute_value = @@ -283,7 +283,7 @@ absl::StatusOr> MaybeAddIndexedContent( case indexes::IndexerType::kHNSW: case indexes::IndexerType::kFlat: { auto vector_index = - dynamic_cast(attribute_info.index); + dynamic_cast(attribute_info.index); auto vector = vector_index->GetValue(neighbor.external_id); if (vector.ok()) { if (parameters.index_schema->GetAttributeDataType().ToProto() == @@ -367,7 +367,7 @@ absl::StatusOr> Search( return absl::InvalidArgumentError( absl::StrCat(parameters.attribute_alias, " is not a Vector index ")); } - auto vector_index = dynamic_cast(index.get()); + auto vector_index = dynamic_cast(index.get()); auto &time_sliced_mutex = parameters.index_schema->GetTimeSlicedMutex(); vmsdk::ReaderMutexLock lock(&time_sliced_mutex); ++Metrics::GetStats().time_slice_queries; diff --git a/src/query/search.h b/src/query/search.h index 933233783..d481ed8fd 100644 --- a/src/query/search.h +++ b/src/query/search.h @@ -112,14 +112,14 @@ size_t EvaluateFilterAsPrimary( // Defined in the header to support testing absl::StatusOr> PerformVectorSearch( - indexes::VectorBase* vector_index, + indexes::VectorBaseField* vector_index, const VectorSearchParameters& parameters); std::priority_queue> CalcBestMatchingPrefilteredKeys( const VectorSearchParameters& parameters, std::queue>& entries_fetchers, - indexes::VectorBase* vector_index); + indexes::VectorBaseField* vector_index); } // namespace valkey_search::query #endif // VALKEYSEARCH_SRC_QUERY_SEARCH_H_ diff --git a/testing/common.cc b/testing/common.cc index fa196dfb7..dd60ff7ff 100644 --- a/testing/common.cc +++ b/testing/common.cc @@ -77,7 +77,7 @@ absl::StatusOr> CreateVectorHNSWSchema( key_prefixes, index_schema_db_num)); auto dimensions = 100; - auto index = indexes::VectorHNSW::Create( + auto index = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, data_model::DISTANCE_METRIC_COSINE, 1000, 10, 300, 30), "vector_identifier", diff --git a/testing/filter_test.cc b/testing/filter_test.cc index 116d8ed1b..6d9c5a217 100644 --- a/testing/filter_test.cc +++ b/testing/filter_test.cc @@ -42,11 +42,11 @@ void InitIndexSchema(MockIndexSchema *index_schema) { data_model::NumericIndex numeric_index_proto; auto numeric_index_1_5 = - std::make_shared>( + std::make_shared>( numeric_index_proto); auto numeric_index_2_0 = - std::make_shared>( + std::make_shared>( numeric_index_proto); VMSDK_EXPECT_OK(numeric_index_1_5->AddRecord("key1", "1.5")); VMSDK_EXPECT_OK(numeric_index_2_0->AddRecord("key1", "2.0")); @@ -59,19 +59,19 @@ void InitIndexSchema(MockIndexSchema *index_schema) { tag_index_proto.set_separator(","); tag_index_proto.set_case_sensitive(true); auto tag_index_1 = - std::make_shared>( + std::make_shared>( tag_index_proto); VMSDK_EXPECT_OK(tag_index_1->AddRecord("key1", "tag1")); VMSDK_EXPECT_OK( index_schema->AddIndex("tag_field_1", "tag_field_1", tag_index_1)); auto tag_index_1_2 = - std::make_shared>( + std::make_shared>( tag_index_proto); VMSDK_EXPECT_OK(tag_index_1_2->AddRecord("key1", "tag2,tag1")); VMSDK_EXPECT_OK( index_schema->AddIndex("tag_field_1_2", "tag_field_1_2", tag_index_1_2)); auto tag_index_with_space = - std::make_shared>( + std::make_shared>( tag_index_proto); VMSDK_EXPECT_OK(tag_index_with_space->AddRecord("key1", "tag 1 ,tag 2")); VMSDK_EXPECT_OK(index_schema->AddIndex( @@ -81,7 +81,7 @@ void InitIndexSchema(MockIndexSchema *index_schema) { tag_case_insensitive_proto.set_separator("@"); tag_case_insensitive_proto.set_case_sensitive(false); auto tag_field_case_insensitive = - std::make_shared>( + std::make_shared>( tag_case_insensitive_proto); VMSDK_EXPECT_OK(tag_field_case_insensitive->AddRecord("key1", "tag1")); VMSDK_EXPECT_OK(index_schema->AddIndex("tag_field_case_insensitive", diff --git a/testing/ft_search_parser_test.cc b/testing/ft_search_parser_test.cc index 2947cc3e1..23dbbbaa2 100644 --- a/testing/ft_search_parser_test.cc +++ b/testing/ft_search_parser_test.cc @@ -123,7 +123,7 @@ void DoVectorSearchParserTest(const FTSearchParserTestCase &test_case, flat_algorithm_proto->set_block_size(100); vector_index_proto.set_allocated_flat_algorithm( flat_algorithm_proto.release()); - auto index = indexes::VectorFlat::Create( + auto index = indexes::VectorFlatField::Create( vector_index_proto, "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); @@ -132,11 +132,11 @@ void DoVectorSearchParserTest(const FTSearchParserTestCase &test_case, } else { // Non Vector index setup data_model::NumericIndex numeric_index_proto; - auto numeric_index = std::make_shared(numeric_index_proto); + auto numeric_index = std::make_shared(numeric_index_proto); VMSDK_EXPECT_OK( index_schema->AddIndex("attribute_identifier_1", "id1", numeric_index)); data_model::TagIndex tag_index_proto; - auto tag_index = std::make_shared(tag_index_proto); + auto tag_index = std::make_shared(tag_index_proto); VMSDK_EXPECT_OK( index_schema->AddIndex("attribute_identifier_2", "id2", tag_index)); } diff --git a/testing/index_schema_test.cc b/testing/index_schema_test.cc index 5fbfa0554..fffe22dbc 100644 --- a/testing/index_schema_test.cc +++ b/testing/index_schema_test.cc @@ -1167,7 +1167,7 @@ TEST_F(IndexSchemaRDBTest, SaveAndLoad) ABSL_NO_THREAD_SAFETY_ANALYSIS { .value(); auto hnsw_index = - indexes::VectorHNSW::Create( + indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "hnsw_attribute", @@ -1190,7 +1190,7 @@ TEST_F(IndexSchemaRDBTest, SaveAndLoad) ABSL_NO_THREAD_SAFETY_ANALYSIS { } auto flat_index = - indexes::VectorFlat::Create( + indexes::VectorFlatField::Create( CreateFlatVectorIndexProto(dimensions, distance_metric, initial_cap, block_size), "flat_identifier", @@ -1224,7 +1224,7 @@ TEST_F(IndexSchemaRDBTest, SaveAndLoad) ABSL_NO_THREAD_SAFETY_ANALYSIS { EXPECT_TRUE(dynamic_cast( &index_schema->GetAttributeDataType())); VMSDK_EXPECT_OK(index_schema->GetIndex("hnsw_attribute")); - auto hnsw_index = dynamic_cast *>( + auto hnsw_index = dynamic_cast *>( index_schema->GetIndex("hnsw_attribute").value().get()); EXPECT_TRUE(hnsw_index != nullptr); EXPECT_EQ(hnsw_index->GetDimensions(), dimensions); @@ -1236,7 +1236,7 @@ TEST_F(IndexSchemaRDBTest, SaveAndLoad) ABSL_NO_THREAD_SAFETY_ANALYSIS { EXPECT_EQ(hnsw_index->GetEfRuntime(), ef_runtime); VMSDK_EXPECT_OK(index_schema->GetIndex("flat_attribute")); - auto flat_index = dynamic_cast *>( + auto flat_index = dynamic_cast *>( index_schema->GetIndex("flat_attribute").value().get()); EXPECT_TRUE(flat_index != nullptr); EXPECT_EQ(flat_index->GetDimensions(), dimensions); @@ -1320,7 +1320,7 @@ class IndexSchemaFriendTest : public ValkeySearchTest { &mutations_thread_pool) .value(); hnsw_index = - indexes::VectorHNSW::Create( + indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), attribute_identifier, @@ -1348,7 +1348,7 @@ class IndexSchemaFriendTest : public ValkeySearchTest { ValkeyModuleCtx fake_ctx; vmsdk::ThreadPool mutations_thread_pool{"writer-thread-pool-", 10}; std::shared_ptr index_schema; - std::shared_ptr> hnsw_index; + std::shared_ptr> hnsw_index; const std::string attribute_identifier{"hnsw_id"}; InternedStringPtr key = StringInternStore::Intern("my_key_"); }; @@ -1625,7 +1625,7 @@ TEST_F(IndexSchemaRDBTest, ComprehensiveSkipLoadTest) { std::make_unique(), nullptr) .value(); - auto hnsw_index = indexes::VectorHNSW::Create( + auto hnsw_index = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "embedding", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) @@ -1756,7 +1756,7 @@ TEST_F(IndexSchemaRDBTest, ComprehensiveSkipLoadTest) { .value(); // Add vector index - auto hnsw_index = indexes::VectorHNSW::Create( + auto hnsw_index = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "embedding", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) @@ -1764,12 +1764,12 @@ TEST_F(IndexSchemaRDBTest, ComprehensiveSkipLoadTest) { VMSDK_EXPECT_OK(index_schema->AddIndex("embedding", "emb_id", hnsw_index)); // Add numeric index - auto numeric_index = std::make_shared( + auto numeric_index = std::make_shared( CreateNumericIndexProto()); VMSDK_EXPECT_OK(index_schema->AddIndex("price", "price_id", numeric_index)); // Add tag index - auto tag_index = std::make_shared( + auto tag_index = std::make_shared( CreateTagIndexProto(",", false)); VMSDK_EXPECT_OK(index_schema->AddIndex("category", "cat_id", tag_index)); @@ -1931,21 +1931,21 @@ TEST_F(IndexSchemaRDBTest, ComprehensiveSkipLoadTest) { .value(); // Create 3 vector indexes (original + 2 additional) - auto hnsw_index1 = indexes::VectorHNSW::Create( + auto hnsw_index1 = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "embedding1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); VMSDK_EXPECT_OK(index_schema->AddIndex("embedding1", "emb1_id", hnsw_index1)); - auto hnsw_index2 = indexes::VectorHNSW::Create( + auto hnsw_index2 = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "embedding2", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); VMSDK_EXPECT_OK(index_schema->AddIndex("embedding2", "emb2_id", hnsw_index2)); - auto flat_index = indexes::VectorFlat::Create( + auto flat_index = indexes::VectorFlatField::Create( CreateFlatVectorIndexProto(dimensions, distance_metric, initial_cap, block_size), "embedding3", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); diff --git a/testing/numeric_index_test.cc b/testing/numeric_index_test.cc index cfaf29c33..14201e22d 100644 --- a/testing/numeric_index_test.cc +++ b/testing/numeric_index_test.cc @@ -26,7 +26,7 @@ namespace { class NumericIndexTest : public vmsdk::ValkeyTest { protected: data_model::NumericIndex numeric_index_proto; - IndexTeser index{numeric_index_proto}; + IndexTeser index{numeric_index_proto}; }; std::vector Fetch( diff --git a/testing/query/fanout_test.cc b/testing/query/fanout_test.cc index 6c7fab968..f1a1c54a6 100644 --- a/testing/query/fanout_test.cc +++ b/testing/query/fanout_test.cc @@ -385,12 +385,12 @@ TEST_P(FanoutTest, TestFanout) { tag_index.set_separator(","); tag_index.set_case_sensitive(false); VMSDK_EXPECT_OK(schema.value()->AddIndex( - "tag_alias", "tag_id", std::make_shared(tag_index))); + "tag_alias", "tag_id", std::make_shared(tag_index))); data_model::NumericIndex numeric_index; VMSDK_EXPECT_OK(schema.value()->AddIndex( "numeric_alias", "numeric_id", - std::make_shared(numeric_index))); + std::make_shared(numeric_index))); InitThreadPools(5, 0); auto mock_coordinator_client_pool = diff --git a/testing/search_test.cc b/testing/search_test.cc index eb83b3d37..dcc336e74 100644 --- a/testing/search_test.cc +++ b/testing/search_test.cc @@ -66,11 +66,11 @@ auto VectorToStr = [](const std::vector &v) { return absl::string_view((char *)v.data(), v.size() * sizeof(float)); }; -class MockNumeric : public indexes::Numeric { +class MockNumeric : public indexes::NumericField { public: MockNumeric(const data_model::NumericIndex &numeric_index_proto) - : indexes::Numeric(numeric_index_proto) {} - MOCK_METHOD(std::unique_ptr, Search, + : indexes::NumericField(numeric_index_proto) {} + MOCK_METHOD(std::unique_ptr, Search, (const query::NumericPredicate &predicate, bool negate), (const, override)); }; @@ -91,16 +91,16 @@ class TestedNumericEntriesFetcherIterator // Mock Numeric EntriesFetcher. // It fetches keys in the range provided at construction time. For example, when // key_range <1, 3> is provided, it will fetch keys "1", "2", "3". -class TestedNumericEntriesFetcher : public indexes::Numeric::EntriesFetcher { +class TestedNumericEntriesFetcher : public indexes::NumericField::EntriesFetcher { public: - TestedNumericEntriesFetcher(indexes::Numeric::EntriesRange &entries_range, + TestedNumericEntriesFetcher(indexes::NumericField::EntriesRange &entries_range, std::pair key_range) - : indexes::Numeric::EntriesFetcher( + : indexes::NumericField::EntriesFetcher( entries_range, key_range.second - key_range.first + 1), key_range_(key_range) {} - TestedNumericEntriesFetcher(indexes::Numeric::EntriesRange &entries_range, + TestedNumericEntriesFetcher(indexes::NumericField::EntriesRange &entries_range, size_t size) - : indexes::Numeric::EntriesFetcher(entries_range, size) { + : indexes::NumericField::EntriesFetcher(entries_range, size) { key_range_ = std::make_pair(0, size - 1); } size_t Size() const override { @@ -122,16 +122,16 @@ class TestedNumericEntriesFetcher : public indexes::Numeric::EntriesFetcher { std::pair key_range_; }; -class MockTag : public indexes::Tag { +class MockTag : public indexes::TagField { public: MockTag(const data_model::TagIndex &tag_index_proto) - : indexes::Tag(tag_index_proto) {} - MOCK_METHOD(std::unique_ptr, Search, + : indexes::TagField(tag_index_proto) {} + MOCK_METHOD(std::unique_ptr, Search, (const query::TagPredicate &predicate, bool negate), (const, override)); }; -class TestedTagEntriesFetcher : public indexes::Tag::EntriesFetcher { +class TestedTagEntriesFetcher : public indexes::TagField::EntriesFetcher { public: TestedTagEntriesFetcher( size_t size, @@ -140,7 +140,7 @@ class TestedTagEntriesFetcher : public indexes::Tag::EntriesFetcher { absl::flat_hash_set *> &entries, bool negate, InternedStringSet &untracked_keys) - : indexes::Tag::EntriesFetcher(tree, entries, size, negate, + : indexes::TagField::EntriesFetcher(tree, entries, size, negate, untracked_keys), size_(size) {} @@ -174,7 +174,7 @@ void InitIndexSchema(MockIndexSchema *index_schema) { "numeric_index_100_10", "numeric_index_100_10", numeric_index_100_10)); VMSDK_EXPECT_OK(index_schema->AddIndex( "numeric_index_100_30", "numeric_index_100_30", numeric_index_100_30)); - indexes::Numeric::EntriesRange entries_range; + indexes::NumericField::EntriesRange entries_range; EXPECT_CALL(*numeric_index_100_10, Search(_, false)) .WillRepeatedly(Return(ByMove( @@ -324,7 +324,7 @@ std::shared_ptr CreateIndexSchemaWithMultipleAttributes( // Add vector index std::shared_ptr vector_index; if (vector_indexer_type == IndexerType::kHNSW) { - vector_index = indexes::VectorHNSW::Create( + vector_index = indexes::VectorHNSWField::Create( CreateHNSWVectorIndexProto( kVectorDimensions, data_model::DISTANCE_METRIC_L2, 1000, 10, 300, 30), @@ -333,7 +333,7 @@ std::shared_ptr CreateIndexSchemaWithMultipleAttributes( .value(); } else { vector_index = - indexes::VectorFlat::Create( + indexes::VectorFlatField::Create( CreateFlatVectorIndexProto( kVectorDimensions, data_model::DISTANCE_METRIC_L2, 1000, 250), "vector_attribute_identifier", @@ -345,14 +345,14 @@ std::shared_ptr CreateIndexSchemaWithMultipleAttributes( // Add numeric index data_model::NumericIndex numeric_index_proto; - auto numeric_index = std::make_shared(numeric_index_proto); + auto numeric_index = std::make_shared(numeric_index_proto); VMSDK_EXPECT_OK(index_schema->AddIndex("numeric", "numeric", numeric_index)); // Add tag index data_model::TagIndex tag_index_proto; tag_index_proto.set_separator(","); tag_index_proto.set_case_sensitive(false); - auto tag_index = std::make_shared(tag_index_proto); + auto tag_index = std::make_shared(tag_index_proto); VMSDK_EXPECT_OK(index_schema->AddIndex("tag", "tag", tag_index)); // Add records @@ -407,7 +407,7 @@ TEST_P(PerformVectorSearchTest, PerformVectorSearchTest) { params.query = VectorToStr(query_vector); FilterParser parser(*index_schema, test_case.filter); params.filter_parse_results = std::move(parser.Parse().value()); - auto vector_index = dynamic_cast( + auto vector_index = dynamic_cast( index_schema->GetIndex(kVectorAttributeAlias)->get()); auto neighbors = PerformVectorSearch(vector_index, params); VMSDK_EXPECT_OK(neighbors); @@ -476,7 +476,7 @@ class FetchFilteredKeysTest TEST_P(FetchFilteredKeysTest, ParseParams) { auto index_schema = CreateIndexSchemaWithMultipleAttributes(); - auto vector_index = dynamic_cast( + auto vector_index = dynamic_cast( index_schema->GetIndex(kVectorAttributeAlias)->get()); const FetchFilteredKeysTestCase &test_case = GetParam(); query::VectorSearchParameters params(100000, nullptr); @@ -487,7 +487,7 @@ TEST_P(FetchFilteredKeysTest, ParseParams) { params.query = std::string((char *)vectors[0].data(), vectors[0].size() * sizeof(float)); std::queue> entries_fetchers; - indexes::Numeric::EntriesRange entries_range; + indexes::NumericField::EntriesRange entries_range; for (auto key_range : test_case.fetched_key_ranges) { entries_fetchers.push(std::make_unique( entries_range, std::make_pair(key_range.first, key_range.second))); @@ -783,7 +783,7 @@ TEST_P(IndexedContentTest, MaybeAddIndexedContentTest) { data_model::VectorIndex vector_index_proto = CreateHNSWVectorIndexProto( kVectorDimensions, distance_metric, 1000, 10, 300, 30); auto vector_index = - indexes::VectorHNSW::Create( + indexes::VectorHNSWField::Create( vector_index_proto, "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); @@ -796,7 +796,7 @@ TEST_P(IndexedContentTest, MaybeAddIndexedContentTest) { data_model::VectorIndex vector_index_proto = CreateFlatVectorIndexProto( kVectorDimensions, distance_metric, 1000, 250); auto flat_index = - indexes::VectorFlat::Create( + indexes::VectorFlatField::Create( vector_index_proto, "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH) .value(); @@ -809,7 +809,7 @@ TEST_P(IndexedContentTest, MaybeAddIndexedContentTest) { data_model::TagIndex tag_index_proto; tag_index_proto.set_separator(","); tag_index_proto.set_case_sensitive(false); - auto tag_index = std::make_shared(tag_index_proto); + auto tag_index = std::make_shared(tag_index_proto); VMSDK_EXPECT_OK(index_schema->AddIndex( index.attribute_alias, index.attribute_identifier, tag_index)); index_base = tag_index; @@ -818,7 +818,7 @@ TEST_P(IndexedContentTest, MaybeAddIndexedContentTest) { case IndexerType::kNumeric: { data_model::NumericIndex numeric_index_proto; auto numeric_index = - std::make_shared(numeric_index_proto); + std::make_shared(numeric_index_proto); VMSDK_EXPECT_OK(index_schema->AddIndex( index.attribute_alias, index.attribute_identifier, numeric_index)); index_base = numeric_index; diff --git a/testing/tag_index_test.cc b/testing/tag_index_test.cc index 111cc4b0e..2999e7bd9 100644 --- a/testing/tag_index_test.cc +++ b/testing/tag_index_test.cc @@ -29,10 +29,10 @@ class TagIndexTest : public vmsdk::ValkeyTest { data_model::TagIndex tag_index_proto; tag_index_proto.set_separator(","); tag_index_proto.set_case_sensitive(false); - index = std::make_unique>( + index = std::make_unique>( tag_index_proto); } - std::unique_ptr> index; + std::unique_ptr> index; std::string identifier = "attribute_id"; std::string alias = "attribute_alias"; }; @@ -58,7 +58,7 @@ TEST_F(TagIndexTest, AddRecordAndSearchTest) { std::string raw_tag_string = "tag1"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); query::TagPredicate predicate(index.get(), alias, identifier, raw_tag_string, parsed_tags); @@ -74,7 +74,7 @@ TEST_F(TagIndexTest, RemoveRecordAndSearchTest) { std::string raw_tag_string = "tag1"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); query::TagPredicate predicate(index.get(), alias, identifier, raw_tag_string, parsed_tags); @@ -89,7 +89,7 @@ TEST_F(TagIndexTest, ModifyRecordAndSearchTest) { std::string raw_tag_string = "tag2.1"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); query::TagPredicate predicate(index.get(), alias, identifier, raw_tag_string, parsed_tags); @@ -107,7 +107,7 @@ TEST_F(TagIndexTest, ModifyRecordWithEmptyString) { std::string raw_tag_string = "tag2"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); query::TagPredicate predicate(index.get(), alias, identifier, raw_tag_string, parsed_tags); @@ -142,7 +142,7 @@ TEST_F(TagIndexTest, PrefixSearchHappyTest) { std::string raw_tag_string = "dis*"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); EXPECT_THAT(parsed_tags, testing::UnorderedElementsAre("dis*")); auto entries_fetcher = @@ -162,7 +162,7 @@ TEST_F(TagIndexTest, PrefixSearchCaseInsensitiveTest) { std::string raw_tag_string = "dIs*"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); EXPECT_THAT(parsed_tags, testing::UnorderedElementsAre("dIs*")); auto entries_fetcher = @@ -174,7 +174,7 @@ TEST_F(TagIndexTest, PrefixSearchCaseInsensitiveTest) { } TEST_F(TagIndexTest, PrefixSearchInvalidTagTest) { - auto status = indexes::Tag::ParseSearchTags("dis**", index->GetSeparator()); + auto status = indexes::TagField::ParseSearchTags("dis**", index->GetSeparator()); EXPECT_EQ(status.status().code(), absl::StatusCode::kInvalidArgument); } @@ -186,7 +186,7 @@ TEST_F(TagIndexTest, PrefixSearchMinLengthNotSatisfiedTest) { std::string raw_tag_string = "d*"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); EXPECT_TRUE(parsed_tags.empty()); @@ -205,7 +205,7 @@ TEST_F(TagIndexTest, PrefixSearchMinLengthSatisfiedTest) { std::string raw_tag_string = "dis*"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); EXPECT_EQ(parsed_tags.size(), 1); @@ -231,7 +231,7 @@ TEST_F(TagIndexTest, NegativeSearchTest) { std::string raw_tag_string = "dis*"; auto parsed_tags = - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value(); EXPECT_EQ(parsed_tags.size(), 1); @@ -255,7 +255,7 @@ TEST_F(TagIndexTest, DeletedKeysNegativeSearchTest) { auto entries_fetcher = index->Search( query::TagPredicate( index.get(), alias, identifier, raw_tag_string, - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value()), true); EXPECT_THAT(Fetch(*entries_fetcher), @@ -267,7 +267,7 @@ TEST_F(TagIndexTest, DeletedKeysNegativeSearchTest) { entries_fetcher = index->Search( query::TagPredicate( index.get(), alias, identifier, raw_tag_string, - indexes::Tag::ParseSearchTags(raw_tag_string, index->GetSeparator()) + indexes::TagField::ParseSearchTags(raw_tag_string, index->GetSeparator()) .value()), true); EXPECT_THAT(Fetch(*entries_fetcher), testing::UnorderedElementsAre("doc0")); diff --git a/testing/vector_test.cc b/testing/vector_test.cc index 2c9e88c56..46229bf05 100644 --- a/testing/vector_test.cc +++ b/testing/vector_test.cc @@ -70,7 +70,7 @@ void TestInitializationHNSW(int dimensions, const std::string& distance_metric_name, int initial_cap, int m, int ef_construction, size_t ef_runtime) ABSL_NO_THREAD_SAFETY_ANALYSIS { - auto index = VectorHNSW::Create( + auto index = VectorHNSWField::Create( CreateHNSWVectorIndexProto(dimensions, distance_metric, initial_cap, m, ef_construction, ef_runtime), "attribute_identifier_1", @@ -95,7 +95,7 @@ TEST_F(VectorIndexTest, InitializationHNSW) { } TEST_F(VectorIndexTest, InitializationFlat) ABSL_NO_THREAD_SAFETY_ANALYSIS { for (auto& distance_metric : kExpectedSpaces) { - auto index = VectorFlat::Create( + auto index = VectorFlatField::Create( CreateFlatVectorIndexProto(kDimensions, distance_metric.first, kInitialCap, kBlockSize), "attribute_identifier_1", @@ -229,7 +229,7 @@ class NormalizeStringRecordTest TEST_P(NormalizeStringRecordTest, NormalizeStringRecord) { auto& params = GetParam(); - auto index = VectorHNSW::Create( + auto index = VectorHNSWField::Create( CreateHNSWVectorIndexProto(kDimensions, data_model::DISTANCE_METRIC_L2, kInitialCap, kM, kEFConstruction, kEFRuntime), "attribute_identifier_1", @@ -279,24 +279,24 @@ INSTANTIATE_TEST_SUITE_P( TEST_F(VectorIndexTest, BasicHNSW) { for (auto& distance_metric : {data_model::DISTANCE_METRIC_COSINE, data_model::DISTANCE_METRIC_L2}) { - auto index = VectorHNSW::Create( + auto index = VectorHNSWField::Create( CreateHNSWVectorIndexProto(kDimensions, distance_metric, kInitialCap, kM, kEFConstruction, kEFRuntime), "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH); - TestIndex>(index->get(), kDimensions, 100); + TestIndex>(index->get(), kDimensions, 100); } } TEST_F(VectorIndexTest, BasicFlat) { for (auto& distance_metric : {data_model::DISTANCE_METRIC_COSINE, data_model::DISTANCE_METRIC_L2}) { - auto index = VectorFlat::Create( + auto index = VectorFlatField::Create( CreateFlatVectorIndexProto(kDimensions, distance_metric, kInitialCap, kBlockSize), "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH); - TestIndex>(index->get(), kDimensions, 100); + TestIndex>(index->get(), kDimensions, 100); } } @@ -304,7 +304,7 @@ TEST_F(VectorIndexTest, ResizeHNSW) ABSL_NO_THREAD_SAFETY_ANALYSIS { for (auto& distance_metric : {data_model::DISTANCE_METRIC_COSINE, data_model::DISTANCE_METRIC_L2}) { const int initial_cap = 10; - auto index = VectorHNSW::Create( + auto index = VectorHNSWField::Create( CreateHNSWVectorIndexProto(kDimensions, distance_metric, initial_cap, kM, kEFConstruction, kEFRuntime), "attribute_identifier_1", @@ -338,7 +338,7 @@ TEST_F(VectorIndexTest, ResizeFlat) ABSL_NO_THREAD_SAFETY_ANALYSIS { for (auto& distance_metric : {data_model::DISTANCE_METRIC_COSINE, data_model::DISTANCE_METRIC_L2}) { const int initial_cap = 10; - auto index = VectorFlat::Create( + auto index = VectorFlatField::Create( CreateFlatVectorIndexProto(kDimensions, distance_metric, initial_cap, kBlockSize), "attribute_identifier_1", @@ -362,7 +362,7 @@ TEST_F(VectorIndexTest, ResizeFlat) ABSL_NO_THREAD_SAFETY_ANALYSIS { } } -float CalcRecall(VectorFlat* flat_index, VectorHNSW* hnsw_index, +float CalcRecall(VectorFlatField* flat_index, VectorHNSWField* hnsw_index, uint64_t k, int dimensions, std::optional ef_runtime) { auto search_vectors = DeterministicallyGenerateVectors(50, dimensions, 1.5); int cnt = 0; @@ -387,7 +387,7 @@ TEST_F(VectorIndexTest, EfRuntimeRecall) { for (auto& distance_metric : {data_model::DISTANCE_METRIC_L2}) { // Use a large cap to make sure chunked array is properly exercised const int initial_cap = 31000; - auto index_hnsw = VectorHNSW::Create( + auto index_hnsw = VectorHNSWField::Create( CreateHNSWVectorIndexProto(kDimensions, distance_metric, initial_cap, kM, kEFConstruction, kEFRuntime), "attribute_identifier_1", @@ -397,7 +397,7 @@ TEST_F(VectorIndexTest, EfRuntimeRecall) { VerifyAdd(index_hnsw->get(), vectors, i, ExpectedResults::kSuccess); } - auto index_flat = VectorFlat::Create( + auto index_flat = VectorFlatField::Create( CreateFlatVectorIndexProto(kDimensions, distance_metric, initial_cap, kBlockSize), "attribute_identifier_1", @@ -427,7 +427,7 @@ TEST_F(VectorIndexTest, SaveAndLoadHnsw) { auto vectors = DeterministicallyGenerateVectors(1000, kDimensions, 2.2); // Load the vectors into a Flat index. This will be used for computing the // recall later - auto index_flat = VectorFlat::Create( + auto index_flat = VectorFlatField::Create( CreateFlatVectorIndexProto(kDimensions, distance_metric, initial_cap, kBlockSize), "attribute_identifier_1", @@ -442,7 +442,7 @@ TEST_F(VectorIndexTest, SaveAndLoadHnsw) { kM, kEFConstruction, kEFRuntime); // Create and save empty HNSW index { - auto index_hnsw = VectorHNSW::Create( + auto index_hnsw = VectorHNSWField::Create( hnsw_proto, "attribute_identifier_2", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH); VMSDK_EXPECT_OK(index_hnsw); @@ -457,7 +457,7 @@ TEST_F(VectorIndexTest, SaveAndLoadHnsw) { // Load the HNSW index, populate data, validate recall, save again { - auto loaded_index_hnsw = VectorHNSW::LoadFromRDB( + auto loaded_index_hnsw = VectorHNSWField::LoadFromRDB( &fake_ctx_, &hash_attribute_data_type_, hnsw_proto, "attribute_identifier_3", SupplementalContentChunkIter(&rdb)); VMSDK_EXPECT_OK(loaded_index_hnsw); @@ -482,7 +482,7 @@ TEST_F(VectorIndexTest, SaveAndLoadHnsw) { // Load the HNSW index, run search queries and validate recall { - auto loaded_index_hnsw = VectorHNSW::LoadFromRDB( + auto loaded_index_hnsw = VectorHNSWField::LoadFromRDB( &fake_ctx_, &hash_attribute_data_type_, hnsw_proto, "attribute_identifier_4", SupplementalContentChunkIter(&rdb)); VMSDK_EXPECT_OK(loaded_index_hnsw); @@ -513,7 +513,7 @@ TEST_F(VectorIndexTest, SaveAndLoadFlat) { kDimensions, distance_metric, initial_cap, kBlockSize); // Create and save empty Flat index { - auto index = VectorFlat::Create( + auto index = VectorFlatField::Create( flat_proto, "attribute_identifier_1", data_model::AttributeDataType::ATTRIBUTE_DATA_TYPE_HASH); if (distance_metric == data_model::DISTANCE_METRIC_COSINE) { @@ -526,7 +526,7 @@ TEST_F(VectorIndexTest, SaveAndLoadFlat) { // Load the index, populate data, perform search, save the index again { - auto index_pr = VectorFlat::LoadFromRDB( + auto index_pr = VectorFlatField::LoadFromRDB( &fake_ctx_, &hash_attribute_data_type_, flat_proto, "attribute_identifier_2", SupplementalContentChunkIter(&rdb)); VMSDK_EXPECT_OK(index_pr); @@ -550,7 +550,7 @@ TEST_F(VectorIndexTest, SaveAndLoadFlat) { // Load the index, run search queries and validate that the search results // match the previous results { - auto index_pr = VectorFlat::LoadFromRDB( + auto index_pr = VectorFlatField::LoadFromRDB( &fake_ctx_, &hash_attribute_data_type_, flat_proto, "attribute_identifier_3", SupplementalContentChunkIter(&rdb)); VMSDK_EXPECT_OK(index_pr); From 339f84890f78a16cd894342525230efda3993214 Mon Sep 17 00:00:00 2001 From: Aksha Thakkar Date: Fri, 8 Aug 2025 03:15:31 +0000 Subject: [PATCH 2/2] DCO Remediation Commit for Aksha Thakkar I, Aksha Thakkar , hereby add my Signed-off-by to this commit: 7c412ba7054f1bf8a7e75f23fc1e7368e06bc7a4 Signed-off-by: Aksha Thakkar --- src/indexes/text/posting.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/indexes/text/posting.h b/src/indexes/text/posting.h index 7f21c1b5e..39a432bc8 100644 --- a/src/indexes/text/posting.h +++ b/src/indexes/text/posting.h @@ -19,7 +19,7 @@ Conceptually, this object holds an ordered list of Keys and for each Key there i an ordered list of Positions. Each position is tagged with a bitmask of fields. A KeyIterator is provided to iterate over the keys within this object. -A PositionIterator is provided to iterate over the positions of an individual Key. +A PositionIterator is provided to iterate over the positions of an individual Key. */