Use MultiValueReadView to read values from struct field attributes.

10 files changed, 130 insertions, 109 deletions

diff --git a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
index 8eba167b9cf..ff5c2c5e05b 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.cpp
@@ -9,6 +9,8 @@
 #include <vespa/searchlib/common/matching_elements.h>
 #include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/data/slime/cursor.h>
+#include <vespa/vespalib/util/stash.h>
+#include <algorithm>
 #include <cassert>
 
 using search::attribute::IAttributeContext;
@@ -21,7 +23,8 @@ namespace {
 
 class ArrayAttributeFieldWriterState : public DocsumFieldWriterState
 {
-    std::vector<std::unique_ptr<AttributeFieldWriter>> _writers;
+    // AttributeFieldWriter instances are owned by stash passed to constructor
+    std::vector<AttributeFieldWriter*>                 _writers;
     const vespalib::string&                            _field_name;
     const MatchingElements* const                      _matching_elements;
 
@@ -29,6 +32,7 @@ public:
     ArrayAttributeFieldWriterState(const std::vector<vespalib::string> &fieldNames,
                                    const std::vector<vespalib::string> &attributeNames,
                                    IAttributeContext &context,
+                                   vespalib::Stash& stash,
                                    const vespalib::string &field_name,
                                    const MatchingElements* matching_elements,
                                    bool is_map_of_scalar);
@@ -40,6 +44,7 @@ public:
 ArrayAttributeFieldWriterState::ArrayAttributeFieldWriterState(const std::vector<vespalib::string> &fieldNames,
                                                                const std::vector<vespalib::string> &attributeNames,
                                                                IAttributeContext &context,
+                                                               vespalib::Stash& stash,
                                                                const vespalib::string &field_name,
                                                                const MatchingElements *matching_elements,
                                                                bool is_map_of_scalar)
@@ -53,7 +58,7 @@ ArrayAttributeFieldWriterState::ArrayAttributeFieldWriterState(const std::vector
     for (uint32_t field = 0; field < fields; ++field) {
         const IAttributeVector *attr = context.getAttribute(attributeNames[field]);
         if (attr != nullptr) {
-            _writers.emplace_back(AttributeFieldWriter::create(fieldNames[field], *attr, is_map_of_scalar));
+            _writers.emplace_back(&AttributeFieldWriter::create(fieldNames[field], *attr, stash, is_map_of_scalar));
         }
     }
 }
@@ -74,10 +79,7 @@ ArrayAttributeFieldWriterState::insertField(uint32_t docId, vespalib::slime::Ins
 {
     uint32_t elems = 0;
     for (auto &writer : _writers) {
-        writer->fetch(docId);
-        if (elems < writer->size()) {
-            elems = writer->size();
-        }
+        elems = std::max(elems, writer->fetch(docId));
     }
     if (elems == 0) {
         return;
@@ -118,11 +120,10 @@ ArrayAttributeCombinerDFW::ArrayAttributeCombinerDFW(const vespalib::string &fie
 
 ArrayAttributeCombinerDFW::~ArrayAttributeCombinerDFW() = default;
 
-std::unique_ptr<DocsumFieldWriterState>
-ArrayAttributeCombinerDFW::allocFieldWriterState(IAttributeContext &context, const MatchingElements* matching_elements)
+DocsumFieldWriterState*
+ArrayAttributeCombinerDFW::allocFieldWriterState(IAttributeContext &context, vespalib::Stash &stash, const MatchingElements* matching_elements)
 {
-    return std::make_unique<ArrayAttributeFieldWriterState>(_fields, _attributeNames, context,
-                                                            _fieldName, matching_elements, _is_map_of_scalar);
+    return &stash.create<ArrayAttributeFieldWriterState>(_fields, _attributeNames, context, stash, _fieldName, matching_elements, _is_map_of_scalar);
 }
 
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
index c36140c5220..18b4fd34e66 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/array_attribute_combiner_dfw.h
@@ -22,7 +22,7 @@ class ArrayAttributeCombinerDFW : public AttributeCombinerDFW
     std::vector<vespalib::string> _attributeNames;
     bool                          _is_map_of_scalar;
 
-    std::unique_ptr<DocsumFieldWriterState> allocFieldWriterState(search::attribute::IAttributeContext &context, const MatchingElements* matching_elements) override;
+    DocsumFieldWriterState* allocFieldWriterState(search::attribute::IAttributeContext &context, vespalib::Stash &stash, const MatchingElements* matching_elements) override;
 public:
     ArrayAttributeCombinerDFW(const vespalib::string &fieldName,
                               const StructFieldsResolver& fields_resolver,
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
index 01fd688f9e0..79c11b20479 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.cpp
@@ -57,13 +57,13 @@ AttributeCombinerDFW::create(const vespalib::string &fieldName, IAttributeContex
 void
 AttributeCombinerDFW::insertField(uint32_t docid, GetDocsumsState *state, ResType, vespalib::slime::Inserter &target)
 {
-    auto &fieldWriterState = state->_fieldWriterStates[_stateIndex];
+    auto& fieldWriterState = state->_fieldWriterStates[_stateIndex];
     if (!fieldWriterState) {
         const MatchingElements *matching_elements = nullptr;
         if (_filter_elements) {
             matching_elements = &state->get_matching_elements(*_matching_elems_fields);
         }
-        fieldWriterState = allocFieldWriterState(*state->_attrCtx, matching_elements);
+        fieldWriterState = allocFieldWriterState(*state->_attrCtx, state->get_stash(), matching_elements);
     }
     fieldWriterState->insertField(docid, target);
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
index f0fed55b5f0..c1742595745 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_combiner_dfw.h
@@ -10,6 +10,8 @@ class MatchingElementsFields;
 }
 namespace search::attribute { class IAttributeContext; }
 
+namespace vespalib { class Stash; }
+
 namespace search::docsummary {
 
 class DocsumFieldWriterState;
@@ -29,7 +31,7 @@ protected:
     AttributeCombinerDFW(const vespalib::string &fieldName, bool filter_elements,
                          std::shared_ptr<MatchingElementsFields> matching_elems_fields);
 protected:
-    virtual std::unique_ptr<DocsumFieldWriterState> allocFieldWriterState(search::attribute::IAttributeContext &context, const MatchingElements* matching_elements) = 0;
+    virtual DocsumFieldWriterState* allocFieldWriterState(search::attribute::IAttributeContext &context, vespalib::Stash& stash, const MatchingElements* matching_elements) = 0;
 public:
     ~AttributeCombinerDFW() override;
     bool IsGenerated() const override;
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.cpp b/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.cpp
index e8777a28775..5668ab82d06 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.cpp
@@ -2,22 +2,22 @@
 
 #include "attribute_field_writer.h"
 #include <vespa/searchcommon/attribute/attributecontent.h>
+#include <vespa/searchcommon/attribute/i_multi_value_attribute.h>
 #include <vespa/searchcommon/common/undefinedvalues.h>
 #include <vespa/vespalib/data/slime/cursor.h>
+#include <vespa/vespalib/util/stash.h>
 #include <cassert>
 
 using search::attribute::BasicType;
 using search::attribute::IAttributeVector;
 using search::attribute::getUndefined;
+using search::attribute::IArrayReadView;
 using vespalib::slime::Cursor;
 
 namespace search::docsummary {
 
-AttributeFieldWriter::AttributeFieldWriter(vespalib::Memory fieldName,
-                                           const IAttributeVector &attr)
-    : _fieldName(fieldName),
-      _attr(attr),
-      _size(0)
+AttributeFieldWriter::AttributeFieldWriter(vespalib::Memory fieldName)
+    : _fieldName(fieldName)
 {
 }
 
@@ -25,78 +25,88 @@ AttributeFieldWriter::~AttributeFieldWriter() = default;
 
 namespace {
 
-template <class Content>
+template <class BasicType>
 class WriteField : public AttributeFieldWriter
 {
 protected:
-    Content _content;
+    const IArrayReadView<BasicType>*   _array_read_view;
+    vespalib::ConstArrayRef<BasicType> _content;
 
-    WriteField(vespalib::Memory fieldName, const IAttributeVector &attr);
+    WriteField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash &stash);
     ~WriteField() override;
 private:
-    void fetch(uint32_t docId) override;
+    uint32_t fetch(uint32_t docId) override;
 };
 
-class WriteStringField : public WriteField<search::attribute::ConstCharContent>
+class WriteStringField : public WriteField<const char*>
 {
 public:
-    WriteStringField(vespalib::Memory fieldName,
-                     const IAttributeVector &attr);
+    WriteStringField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash);
     ~WriteStringField() override;
     void print(uint32_t idx, Cursor &cursor) override;
 };
 
-class WriteStringFieldNeverSkip : public WriteField<search::attribute::ConstCharContent>
+class WriteStringFieldNeverSkip : public WriteField<const char*>
 {
 public:
-    WriteStringFieldNeverSkip(vespalib::Memory fieldName,
-                             const IAttributeVector &attr)
-      : WriteField(fieldName, attr) {}
+    WriteStringFieldNeverSkip(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash)
+        : WriteField(fieldName, attr, stash) {}
     ~WriteStringFieldNeverSkip() override {}
     void print(uint32_t idx, Cursor &cursor) override;
 };
 
-class WriteFloatField : public WriteField<search::attribute::FloatContent>
+template <typename BasicType>
+class WriteFloatField : public WriteField<BasicType>
 {
 public:
-    WriteFloatField(vespalib::Memory fieldName,
-                    const IAttributeVector &attr);
+    WriteFloatField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash);
     ~WriteFloatField() override;
     void print(uint32_t idx, Cursor &cursor) override;
 };
 
-class WriteIntField : public WriteField<search::attribute::IntegerContent>
+template <typename BasicType>
+class WriteIntField : public WriteField<BasicType>
 {
-    IAttributeVector::largeint_t _undefined;
 public:
-    WriteIntField(vespalib::Memory fieldName,
-                  const IAttributeVector &attr,
-                  IAttributeVector::largeint_t undefined);
+    WriteIntField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash);
     ~WriteIntField() override;
     void print(uint32_t idx, Cursor &cursor) override;
 };
 
-template <class Content>
-WriteField<Content>::WriteField(vespalib::Memory fieldName, const IAttributeVector &attr)
-    : AttributeFieldWriter(fieldName, attr),
+template <typename BasicType>
+const search::attribute::IArrayReadView<BasicType>*
+make_array_read_view(const IAttributeVector& attribute, vespalib::Stash& stash)
+{
+    auto multi_value_attribute = attribute.as_multi_value_attribute();
+    if (multi_value_attribute != nullptr) {
+        return multi_value_attribute->make_read_view(search::attribute::IMultiValueAttribute::ArrayTag<BasicType>(), stash);
+    }
+    return nullptr;
+}
+
+template <class BasicType>
+WriteField<BasicType>::WriteField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash)
+    : AttributeFieldWriter(fieldName),
+      _array_read_view(make_array_read_view<BasicType>(attr, stash)),
       _content()
 {
 }
 
-template <class Content>
-WriteField<Content>::~WriteField() = default;
+template <class BasicType>
+WriteField<BasicType>::~WriteField() = default;
 
-template <class Content>
-void
-WriteField<Content>::fetch(uint32_t docId)
+template <class BasicType>
+uint32_t
+WriteField<BasicType>::fetch(uint32_t docId)
 {
-    _content.fill(_attr, docId);
-    _size = _content.size();
+    if (_array_read_view) {
+        _content = _array_read_view->get_values(docId);
+    }
+    return _content.size();
 }
 
-WriteStringField::WriteStringField(vespalib::Memory fieldName,
-                                   const IAttributeVector &attr)
-    : WriteField(fieldName, attr)
+WriteStringField::WriteStringField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash)
+    : WriteField(fieldName, attr, stash)
 {
 }
 
@@ -105,7 +115,7 @@ WriteStringField::~WriteStringField() = default;
 void
 WriteStringField::print(uint32_t idx, Cursor &cursor)
 {
-    if (idx < _size) {
+    if (idx < _content.size()) {
         const char *s = _content[idx];
         if (s[0] != '\0') {
             cursor.setString(_fieldName, vespalib::Memory(s));
@@ -116,7 +126,7 @@ WriteStringField::print(uint32_t idx, Cursor &cursor)
 void
 WriteStringFieldNeverSkip::print(uint32_t idx, Cursor &cursor)
 {
-    if (idx < _size) {
+    if (idx < _content.size()) {
         const char *s = _content[idx];
         cursor.setString(_fieldName, vespalib::Memory(s));
     } else {
@@ -124,68 +134,71 @@ WriteStringFieldNeverSkip::print(uint32_t idx, Cursor &cursor)
     }
 }
 
-WriteFloatField::WriteFloatField(vespalib::Memory fieldName,
-                                 const IAttributeVector &attr)
-    : WriteField(fieldName, attr)
+template <typename BasicType>
+WriteFloatField<BasicType>::WriteFloatField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash)
+    : WriteField<BasicType>(fieldName, attr, stash)
 {
 }
 
-WriteFloatField::~WriteFloatField() = default;
+template <typename BasicType>
+WriteFloatField<BasicType>::~WriteFloatField() = default;
 
+template <typename BasicType>
 void
-WriteFloatField::print(uint32_t idx, Cursor &cursor)
+WriteFloatField<BasicType>::print(uint32_t idx, Cursor &cursor)
 {
-    if (idx < _size) {
-        double val = _content[idx];
+    if (idx < this->_content.size()) {
+        double val = this->_content[idx];
         if (!search::attribute::isUndefined(val)) {
-            cursor.setDouble(_fieldName, val);
+            cursor.setDouble(this->_fieldName, val);
         }
     }
 }
 
-WriteIntField::WriteIntField(vespalib::Memory fieldName,
-                             const IAttributeVector &attr,
-                             IAttributeVector::largeint_t undefined)
-    : WriteField(fieldName, attr),
-      _undefined(undefined)
+template <typename BasicType>
+WriteIntField<BasicType>::WriteIntField(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash)
+    : WriteField<BasicType>(fieldName, attr, stash)
 {
 }
 
-WriteIntField::~WriteIntField() = default;
+template <typename BasicType>
+WriteIntField<BasicType>::~WriteIntField() = default;
 
+template <typename BasicType>
 void
-WriteIntField::print(uint32_t idx, Cursor &cursor)
+WriteIntField<BasicType>::print(uint32_t idx, Cursor &cursor)
 {
-    if (idx < _size) {
-        auto val = _content[idx];
-        if (val != _undefined) {
-            cursor.setLong(_fieldName, _content[idx]);
+    if (idx < this->_content.size()) {
+        auto val = this->_content[idx];
+        if (val != getUndefined<BasicType>()) {
+            cursor.setLong(this->_fieldName, val);
         }
     }
 }
 
 }
 
-std::unique_ptr<AttributeFieldWriter>
-AttributeFieldWriter::create(vespalib::Memory fieldName, const IAttributeVector &attr, bool keep_empty_strings)
+AttributeFieldWriter&
+AttributeFieldWriter::create(vespalib::Memory fieldName, const IAttributeVector& attr, vespalib::Stash& stash, bool keep_empty_strings)
 {
     switch (attr.getBasicType()) {
     case BasicType::INT8:
-        return std::make_unique<WriteIntField>(fieldName, attr, getUndefined<int8_t>());
+        return stash.create<WriteIntField<int8_t>>(fieldName, attr, stash);
     case BasicType::INT16:
-        return std::make_unique<WriteIntField>(fieldName, attr, getUndefined<int16_t>());
+        return stash.create<WriteIntField<int16_t>>(fieldName, attr, stash);
     case BasicType::INT32:
-        return std::make_unique<WriteIntField>(fieldName, attr, getUndefined<int32_t>());
+        return stash.create<WriteIntField<int32_t>>(fieldName, attr, stash);
     case BasicType::INT64:
-        return std::make_unique<WriteIntField>(fieldName, attr, getUndefined<int64_t>());
+        return stash.create<WriteIntField<int64_t>>(fieldName, attr, stash);
     case BasicType::FLOAT:
+        return stash.create<WriteFloatField<float>>(fieldName, attr, stash);
     case BasicType::DOUBLE:
-        return std::make_unique<WriteFloatField>(fieldName, attr);
+        return stash.create<WriteFloatField<double>>(fieldName, attr, stash);
     case BasicType::STRING:
         if (keep_empty_strings) {
-            return std::make_unique<WriteStringFieldNeverSkip>(fieldName, attr);
+            return stash.create<WriteStringFieldNeverSkip>(fieldName, attr, stash);
         } else {
-            return std::make_unique<WriteStringField>(fieldName, attr);
+            return stash.create<WriteStringField>(fieldName, attr, stash);
         }
     default:
         assert(false);
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.h b/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.h
index eb108a9681d..5c04328d01e 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/attribute_field_writer.h
@@ -6,6 +6,7 @@
 #include <memory>
 
 namespace search::attribute { class IAttributeVector; }
+namespace vespalib { class Stash; }
 namespace vespalib::slime { struct Cursor; }
 
 namespace search::docsummary {
@@ -20,16 +21,13 @@ class AttributeFieldWriter
 {
 protected:
     const vespalib::Memory                     _fieldName;
-    const search::attribute::IAttributeVector &_attr;
-    size_t                                     _size;
-    AttributeFieldWriter(vespalib::Memory fieldName,
-                         const search::attribute::IAttributeVector &attr);
+    AttributeFieldWriter(vespalib::Memory fieldName);
 public:
     virtual ~AttributeFieldWriter();
-    virtual void fetch(uint32_t docId) = 0;
+    virtual uint32_t fetch(uint32_t docId) = 0;
     virtual void print(uint32_t idx, vespalib::slime::Cursor &cursor) = 0;
-    static std::unique_ptr<AttributeFieldWriter> create(vespalib::Memory fieldName, const search::attribute::IAttributeVector &attr, bool keep_empty_strings = false);
-    uint32_t size() const { return _size; }
+    // Create a new attribute field writer which is owned by stash
+    static AttributeFieldWriter& create(vespalib::Memory fieldName, const search::attribute::IAttributeVector& attr, vespalib::Stash& stash, bool keep_empty_strings = false);
 };
 
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
index 4f1634042c1..e538af3839e 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.cpp
@@ -32,6 +32,7 @@ GetDocsumsState::GetDocsumsState(GetDocsumsStateCallback &callback)
       _dynteaser(),
       _attrCtx(),
       _attributes(),
+      _stash(),
       _fieldWriterStates(),
       _parsedLocations(),
       _summaryFeatures(nullptr),
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
index 85d24d25c62..1127af6d6bd 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/docsumstate.h
@@ -7,6 +7,7 @@
 #include <vespa/searchlib/common/featureset.h>
 #include <vespa/searchlib/common/geo_location_spec.h>
 #include <vespa/vespalib/util/jsonwriter.h>
+#include <vespa/vespalib/util/stash.h>
 
 namespace juniper {
     class Config;
@@ -73,7 +74,11 @@ public:
 
     std::unique_ptr<search::attribute::IAttributeContext> _attrCtx;
     std::vector<const search::attribute::IAttributeVector *> _attributes;
-    std::vector<std::unique_ptr<DocsumFieldWriterState>> _fieldWriterStates;
+private:
+    vespalib::Stash _stash;
+public:
+    // DocsumFieldWriterState instances are owned by _stash
+    std::vector<DocsumFieldWriterState*> _fieldWriterStates;
 
     // used by AbsDistanceDFW
     std::vector<search::common::GeoLocationSpec> _parsedLocations;
@@ -97,6 +102,7 @@ public:
 
     const MatchingElements &get_matching_elements(const MatchingElementsFields &matching_elems_fields);
     vespalib::JSONStringer & jsonStringer();
+    vespalib::Stash& get_stash() noexcept { return _stash; }
 private:
     // Only used by rank/summary features, so make it lazy
     std::unique_ptr<vespalib::JSONStringer>   _jsonStringer;
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
index ee9ca92c15b..aec55977546 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.cpp
@@ -9,6 +9,8 @@
 #include <vespa/searchlib/common/matching_elements.h>
 #include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vespalib/data/slime/cursor.h>
+#include <vespa/vespalib/util/stash.h>
+#include <algorithm>
 #include <cassert>
 
 using search::attribute::IAttributeContext;
@@ -24,16 +26,19 @@ vespalib::Memory valueName("value");
 
 class StructMapAttributeFieldWriterState : public DocsumFieldWriterState
 {
-    std::unique_ptr<AttributeFieldWriter> _keyWriter;
-    std::vector<std::unique_ptr<AttributeFieldWriter>> _valueWriters;
-    const vespalib::string&                            _field_name; 
-    const MatchingElements* const                      _matching_elements;
+    // AttributeFieldWriter instance is owned by stash passed to constructor
+    AttributeFieldWriter*              _keyWriter;
+    // AttributeFieldWriter instances are owned by stash passed to constructor
+    std::vector<AttributeFieldWriter*> _valueWriters;
+    const vespalib::string&            _field_name;
+    const MatchingElements* const      _matching_elements;
 
 public:
     StructMapAttributeFieldWriterState(const vespalib::string &keyAttributeName,
                                        const std::vector<vespalib::string> &valueFieldNames,
                                        const std::vector<vespalib::string> &valueAttributeNames,
                                        IAttributeContext &context,
+                                       vespalib::Stash& stash,
                                        const vespalib::string &field_name,
                                        const MatchingElements* matching_elements);
     ~StructMapAttributeFieldWriterState() override;
@@ -45,24 +50,25 @@ StructMapAttributeFieldWriterState::StructMapAttributeFieldWriterState(const ves
                                                                        const std::vector<vespalib::string> &valueFieldNames,
                                                                        const std::vector<vespalib::string> &valueAttributeNames,
                                                                        IAttributeContext &context,
-                                                                       const vespalib::string& field_name, 
+                                                                       vespalib::Stash& stash,
+                                                                       const vespalib::string& field_name,
                                                                        const MatchingElements *matching_elements)
     : DocsumFieldWriterState(),
-      _keyWriter(),
+      _keyWriter(nullptr),
       _valueWriters(),
       _field_name(field_name),
       _matching_elements(matching_elements)
 {
     const IAttributeVector *attr = context.getAttribute(keyAttributeName);
     if (attr != nullptr) {
-        _keyWriter = AttributeFieldWriter::create(keyName, *attr, true);
+        _keyWriter = &AttributeFieldWriter::create(keyName, *attr, stash, true);
     }
     size_t fields = valueFieldNames.size();
     _valueWriters.reserve(fields);
     for (uint32_t field = 0; field < fields; ++field) {
         attr = context.getAttribute(valueAttributeNames[field]);
         if (attr != nullptr) {
-            _valueWriters.emplace_back(AttributeFieldWriter::create(valueFieldNames[field], *attr));
+            _valueWriters.emplace_back(&AttributeFieldWriter::create(valueFieldNames[field], *attr, stash));
         }
     }
 }
@@ -87,16 +93,10 @@ StructMapAttributeFieldWriterState::insertField(uint32_t docId, vespalib::slime:
 {
     uint32_t elems = 0;
     if (_keyWriter) {
-        _keyWriter->fetch(docId);
-        if (elems < _keyWriter->size()) {
-            elems = _keyWriter->size();
-        }
+        elems = _keyWriter->fetch(docId);
     }
     for (auto &valueWriter : _valueWriters) {
-        valueWriter->fetch(docId);
-        if (elems < valueWriter->size()) {
-            elems = valueWriter->size();
-        }
+        elems = std::max(elems, valueWriter->fetch(docId));
     }
     if (elems == 0) {
         return;
@@ -137,10 +137,10 @@ StructMapAttributeCombinerDFW::StructMapAttributeCombinerDFW(const vespalib::str
 
 StructMapAttributeCombinerDFW::~StructMapAttributeCombinerDFW() = default;
 
-std::unique_ptr<DocsumFieldWriterState>
-StructMapAttributeCombinerDFW::allocFieldWriterState(IAttributeContext &context, const MatchingElements* matching_elements)
+DocsumFieldWriterState*
+StructMapAttributeCombinerDFW::allocFieldWriterState(IAttributeContext &context, vespalib::Stash& stash, const MatchingElements* matching_elements)
 {
-    return std::make_unique<StructMapAttributeFieldWriterState>(_keyAttributeName, _valueFields, _valueAttributeNames, context, _fieldName, matching_elements);
+    return &stash.create<StructMapAttributeFieldWriterState>(_keyAttributeName, _valueFields, _valueAttributeNames, context, stash, _fieldName, matching_elements);
 }
 
 }
diff --git a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
index 84e89477fd2..74ba61dce14 100644
--- a/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
+++ b/searchsummary/src/vespa/searchsummary/docsummary/struct_map_attribute_combiner_dfw.h
@@ -21,7 +21,7 @@ class StructMapAttributeCombinerDFW : public AttributeCombinerDFW
     std::vector<vespalib::string> _valueFields;
     std::vector<vespalib::string> _valueAttributeNames;
 
-    std::unique_ptr<DocsumFieldWriterState> allocFieldWriterState(search::attribute::IAttributeContext &context, const MatchingElements* matching_elements) override;
+    DocsumFieldWriterState* allocFieldWriterState(search::attribute::IAttributeContext &context, vespalib::Stash& stash, const MatchingElements* matching_elements) override;
 public:
     StructMapAttributeCombinerDFW(const vespalib::string &fieldName,
                                   const StructFieldsResolver& fields_resolver,