Add an interface to getting an optional readonly singlevalue enumvector.

8 files changed, 61 insertions, 44 deletions

diff --git a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
index 51e95204b2b..aa2c475e7b6 100644
--- a/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
+++ b/searchlib/src/tests/attribute/stringattribute/stringattribute_test.cpp
@@ -7,9 +7,7 @@
 #include <vespa/searchlib/attribute/multistringpostattribute.h>
 
 #include <vespa/searchlib/attribute/enumstore.hpp>
-#include <vespa/searchlib/attribute/singlestringattribute.h>
 #include <vespa/searchlib/attribute/singlestringpostattribute.hpp>
-#include <vespa/searchlib/attribute/multistringattribute.h>
 #include <vespa/searchlib/attribute/multistringpostattribute.hpp>
 
 #include <vespa/log/log.h>
@@ -393,8 +391,6 @@ TEST("testSingleValue")
     {
         Config cfg(BasicType::STRING, CollectionType::SINGLE);
         SingleValueStringAttribute svsa("svsa", cfg);
-        const IAttributeVector * ia = &svsa;
-        EXPECT_TRUE(dynamic_cast<const SingleValueEnumAttributeBase *>(ia) != nullptr);
         testSingleValue(svsa, cfg);
 
         SingleValueStringAttribute svsb("svsa", cfg);
diff --git a/searchlib/src/vespa/searchcommon/attribute/iattributevector.h b/searchlib/src/vespa/searchcommon/attribute/iattributevector.h
index bac5181871a..837aead18fd 100644
--- a/searchlib/src/vespa/searchcommon/attribute/iattributevector.h
+++ b/searchlib/src/vespa/searchcommon/attribute/iattributevector.h
@@ -5,6 +5,8 @@
 #include "collectiontype.h"
 #include "basictype.h"
 #include <vespa/searchcommon/common/iblobconverter.h>
+#include <vespa/vespalib/datastore/atomic_entry_ref.h>
+#include <vespa/vespalib/util/arrayref.h>
 #include <ostream>
 #include <vector>
 
@@ -73,6 +75,7 @@ public:
     using WeightedEnum = WeightedType<EnumHandle>;
     using WeightedConstChar = WeightedType<const char *>;
     using WeightedString = WeightedType<vespalib::string>;
+    using EnumRefs = vespalib::ConstArrayRef<vespalib::datastore::AtomicEntryRef>;
 
     /**
      * Returns the name of this attribute vector.
@@ -425,7 +428,7 @@ public:
      * @param bc An optional converter to use.
      * @return The number of bytes serialized, -1 if not enough space.
      */
-    long serializeForAscendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc=NULL) const {
+    long serializeForAscendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc=nullptr) const {
         return onSerializeForAscendingSort(doc, serTo, available, bc);
     }
     /**
@@ -437,7 +440,7 @@ public:
      * @param bc An optional converter to use.
      * @return The number of bytes serialized, -1 if not enough space.
      */
-    long serializeForDescendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc=NULL) const {
+    long serializeForDescendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc=nullptr) const {
         return onSerializeForDescendingSort(doc, serTo, available, bc);
     }
 
@@ -453,6 +456,15 @@ public:
      */
     virtual bool isUndefined(DocId doc) const { (void) doc; return false; }
 
+    /**
+     * Will return a readonly view of any single value enumeration. If not applicable an empty one will be returned.
+     *
+     * @return returns a readonly enumrefs view with entries equal to number of docs committed.
+     */
+    virtual EnumRefs make_enum_read_view() const noexcept {
+        return EnumRefs();
+    }
+
 private:
     virtual long onSerializeForAscendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc) const = 0;
     virtual long onSerializeForDescendingSort(DocId doc, void * serTo, long available, const common::BlobConverter * bc) const = 0;
diff --git a/searchlib/src/vespa/searchlib/attribute/diversity.cpp b/searchlib/src/vespa/searchlib/attribute/diversity.cpp
index 41f6539884e..d73ab086d19 100644
--- a/searchlib/src/vespa/searchlib/attribute/diversity.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/diversity.cpp
@@ -1,7 +1,6 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "diversity.hpp"
-#include "singleenumattribute.h"
 #include "singlenumericattribute.h"
 #include <vespa/vespalib/stllike/hash_map.h>
 
@@ -18,11 +17,11 @@ struct FetchNumberFast {
 };
 
 struct FetchEnumFast {
-    const SingleValueEnumAttributeBase * const attr;
+    IAttributeVector::EnumRefs enumRefs;
     typedef uint32_t ValueType;
-    FetchEnumFast(const IAttributeVector &attr_in) : attr(dynamic_cast<const SingleValueEnumAttributeBase *>(&attr_in)) {}
-    ValueType get(uint32_t docid) const { return attr->getE(docid); }
-    bool valid() const { return (attr != nullptr); }
+    FetchEnumFast(const IAttributeVector &attr) : enumRefs(attr.make_enum_read_view()) {}
+    ValueType get(uint32_t docid) const { return enumRefs[docid].load_relaxed().ref(); }
+    bool valid() const { return ! enumRefs.empty(); }
 };
 
 struct FetchEnum {
diff --git a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
index f606b1afdab..6e46c697fbc 100644
--- a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
@@ -25,17 +25,14 @@ protected:
     using EnumIndex = IEnumStore::Index;
     using EnumIndexRemapper = IEnumStore::EnumIndexRemapper;
     using GenerationHolder = vespalib::GenerationHolder;
-
+    using EnumRefs = attribute::IAttributeVector::EnumRefs;
 public:
     using EnumIndexCopyVector = vespalib::Array<EnumIndex>;
-
 protected:
-    EntryRef acquire_enum_entry_ref(DocId docId) const noexcept { return _enumIndices.acquire_elem_ref(docId).load_acquire(); }
 
-public:
-    IEnumStore::Index getEnumIndex(DocId docId) const noexcept { return acquire_enum_entry_ref(docId); }
+    EntryRef acquire_enum_entry_ref(DocId docId) const noexcept { return _enumIndices.acquire_elem_ref(docId).load_acquire(); }
     EnumHandle getE(DocId doc) const noexcept { return acquire_enum_entry_ref(doc).ref(); }
-protected:
+    EnumRefs make_read_view(size_t read_size) const noexcept { return _enumIndices.make_read_view(read_size); }
     SingleValueEnumAttributeBase(const attribute::Config & c, GenerationHolder &genHolder, const vespalib::alloc::Alloc& initial_alloc);
     ~SingleValueEnumAttributeBase();
     AttributeVector::DocId addDoc(bool & incGeneration);
@@ -64,6 +61,9 @@ protected:
 private:
     void considerUpdateAttributeChange(const Change & c, EnumStoreBatchUpdater & inserter);
     void applyUpdateValueChange(const Change& c, EnumStoreBatchUpdater& updater);
+    EnumRefs make_enum_read_view() const noexcept override {
+        return make_read_view(this->getCommittedDocIdLimit());
+    }
 
 protected:
     // from EnumAttribute
diff --git a/searchlib/src/vespa/searchlib/attribute/singleenumattributesaver.h b/searchlib/src/vespa/searchlib/attribute/singleenumattributesaver.h
index c2d63c2b017..3ebeb2ba1d2 100644
--- a/searchlib/src/vespa/searchlib/attribute/singleenumattributesaver.h
+++ b/searchlib/src/vespa/searchlib/attribute/singleenumattributesaver.h
@@ -14,19 +14,18 @@ namespace search {
 class SingleValueEnumAttributeSaver : public AttributeSaver
 {
 private:
-    using EnumIndexCopyVector =
-        SingleValueEnumAttributeBase::EnumIndexCopyVector;
+    using EnumIndexCopyVector = SingleValueEnumAttributeBase::EnumIndexCopyVector;
     EnumIndexCopyVector _indices;
     EnumAttributeSaver  _enumSaver;
 
-    virtual bool onSave(IAttributeSaveTarget &saveTarget) override;
+    bool onSave(IAttributeSaveTarget &saveTarget) override;
 public:
     SingleValueEnumAttributeSaver(vespalib::GenerationHandler::Guard &&guard,
                                   const attribute::AttributeHeader &header,
                                   EnumIndexCopyVector &&indices,
                                   const IEnumStore &enumStore);
 
-    virtual ~SingleValueEnumAttributeSaver();
+    ~SingleValueEnumAttributeSaver() override;
 };
 
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/expression/attributenode.cpp b/searchlib/src/vespa/searchlib/expression/attributenode.cpp
index b239777cc87..9b10dfd0a92 100644
--- a/searchlib/src/vespa/searchlib/expression/attributenode.cpp
+++ b/searchlib/src/vespa/searchlib/expression/attributenode.cpp
@@ -72,11 +72,13 @@ private:
 
 namespace {
 
-std::unique_ptr<AttributeResult> createResult(const IAttributeVector * attribute)
+std::unique_ptr<AttributeResult>
+createResult(const IAttributeVector * attribute)
 {
-    return (dynamic_cast<const SingleValueEnumAttributeBase *>(attribute) != nullptr)
-        ? std::make_unique<EnumAttributeResult>(attribute, 0)
-        : std::make_unique<AttributeResult>(attribute, 0);
+    IAttributeVector::EnumRefs enumRefs = attribute->make_enum_read_view();
+    return (enumRefs.empty())
+        ? std::make_unique<AttributeResult>(attribute, 0)
+        : std::make_unique<EnumAttributeResult>(enumRefs, attribute, 0);
 }
 
 }
@@ -120,7 +122,8 @@ AttributeNode::AttributeNode(const AttributeNode & attribute) :
     _scratchResult->setDocId(0);
 }
 
-AttributeNode & AttributeNode::operator = (const AttributeNode & attr)
+AttributeNode &
+AttributeNode::operator = (const AttributeNode & attr)
 {
     if (this != &attr) {
         FunctionNode::operator = (attr);
@@ -133,7 +136,8 @@ AttributeNode & AttributeNode::operator = (const AttributeNode & attr)
     return *this;
 }
 
-void AttributeNode::onPrepare(bool preserveAccurateTypes)
+void
+AttributeNode::onPrepare(bool preserveAccurateTypes)
 {
     const IAttributeVector * attribute = _scratchResult->getAttribute();
     if (attribute != nullptr) {
@@ -225,7 +229,8 @@ void AttributeNode::onPrepare(bool preserveAccurateTypes)
 }
 
 template <typename V>
-void AttributeNode::IntegerHandler<V>::handle(const AttributeResult & r)
+void
+AttributeNode::IntegerHandler<V>::handle(const AttributeResult & r)
 {
     size_t numValues = r.getAttribute()->getValueCount(r.getDocId());
     _vector.resize(numValues);
@@ -236,7 +241,8 @@ void AttributeNode::IntegerHandler<V>::handle(const AttributeResult & r)
     }
 }
 
-void AttributeNode::FloatHandler::handle(const AttributeResult & r)
+void
+AttributeNode::FloatHandler::handle(const AttributeResult & r)
 {
     size_t numValues = r.getAttribute()->getValueCount(r.getDocId());
     _vector.resize(numValues);
@@ -247,7 +253,8 @@ void AttributeNode::FloatHandler::handle(const AttributeResult & r)
     }
 }
 
-void AttributeNode::StringHandler::handle(const AttributeResult & r)
+void
+AttributeNode::StringHandler::handle(const AttributeResult & r)
 {
     size_t numValues = r.getAttribute()->getValueCount(r.getDocId());
     _vector.resize(numValues);
@@ -279,7 +286,8 @@ bool AttributeNode::onExecute() const
     return true;
 }
 
-void AttributeNode::wireAttributes(const IAttributeContext & attrCtx)
+void
+AttributeNode::wireAttributes(const IAttributeContext & attrCtx)
 {
     const IAttributeVector * attribute(_scratchResult ? _scratchResult->getAttribute() : nullptr);
     if (attribute == nullptr) {
@@ -296,18 +304,21 @@ void AttributeNode::wireAttributes(const IAttributeContext & attrCtx)
     }
 }
 
-void AttributeNode::cleanup()
+void
+AttributeNode::cleanup()
 {
     _scratchResult.reset();
 }
 
-Serializer & AttributeNode::onSerialize(Serializer & os) const
+Serializer &
+AttributeNode::onSerialize(Serializer & os) const
 {
     FunctionNode::onSerialize(os);
     return os << _attributeName;
 }
 
-Deserializer & AttributeNode::onDeserialize(Deserializer & is)
+Deserializer &
+AttributeNode::onDeserialize(Deserializer & is)
 {
     FunctionNode::onDeserialize(is);
 
diff --git a/searchlib/src/vespa/searchlib/expression/attributeresult.h b/searchlib/src/vespa/searchlib/expression/attributeresult.h
index d71bdc2b7e0..a4ff376526d 100644
--- a/searchlib/src/vespa/searchlib/expression/attributeresult.h
+++ b/searchlib/src/vespa/searchlib/expression/attributeresult.h
@@ -12,7 +12,7 @@ class AttributeResult : public ResultNode
 public:
     typedef std::unique_ptr<AttributeResult> UP;
     DECLARE_RESULTNODE(AttributeResult);
-    AttributeResult() : _attribute(NULL), _docId(0) { }
+    AttributeResult() : _attribute(nullptr), _docId(0) { }
     AttributeResult(const attribute::IAttributeVector * attribute, DocId docId) :
         _attribute(attribute),
         _docId(docId)
diff --git a/searchlib/src/vespa/searchlib/expression/enumattributeresult.h b/searchlib/src/vespa/searchlib/expression/enumattributeresult.h
index 146233fe064..655cc62fa00 100644
--- a/searchlib/src/vespa/searchlib/expression/enumattributeresult.h
+++ b/searchlib/src/vespa/searchlib/expression/enumattributeresult.h
@@ -3,26 +3,26 @@
 #pragma once
 
 #include "attributeresult.h"
-#include <vespa/searchlib/attribute/singleenumattribute.h>
 
 namespace search::expression {
 
-class EnumAttributeResult : public AttributeResult
+class EnumAttributeResult final : public AttributeResult
 {
 public:
+    using EnumRefs = attribute::IAttributeVector::EnumRefs;
     DECLARE_RESULTNODE(EnumAttributeResult);
-    EnumAttributeResult(const attribute::IAttributeVector * attribute, DocId docId) :
+    EnumAttributeResult(EnumRefs enumRefs, const attribute::IAttributeVector * attribute, DocId docId) :
         AttributeResult(attribute, docId),
-        _enumAttr(dynamic_cast<const SingleValueEnumAttributeBase *>(attribute))
+        _enumRefs(enumRefs)
     {
     }
 private:
-    EnumAttributeResult() :
-        AttributeResult(),
-        _enumAttr(NULL)
+    EnumAttributeResult()
+        : AttributeResult(),
+          _enumRefs()
     { }
-    int64_t onGetEnum(size_t index) const override { (void) index; return (static_cast<int64_t>(_enumAttr->getE(getDocId()))); }
-    const SingleValueEnumAttributeBase * _enumAttr;
+    int64_t onGetEnum(size_t index) const override { (void) index; return (static_cast<int64_t>(_enumRefs[getDocId()].load_relaxed().ref())); }
+    EnumRefs _enumRefs;
 };
 
 }