Merge pull request #2203 from yahoo/toregge/delay-summary-map-changes

Delay changes to summarymap config when delaying changes to attribute…

8 files changed, 184 insertions, 59 deletions

diff --git a/searchcore/src/apps/tests/persistenceconformance_test.cpp b/searchcore/src/apps/tests/persistenceconformance_test.cpp
index f7d40d766a8..18a51115089 100644
--- a/searchcore/src/apps/tests/persistenceconformance_test.cpp
+++ b/searchcore/src/apps/tests/persistenceconformance_test.cpp
@@ -114,7 +114,7 @@ public:
         SchemaBuilder::build(*attributes, *schema);
         SchemaBuilder::build(*summary, *schema);
         AttributeSpecsBuilder attributeSpecsBuilder;
-        attributeSpecsBuilder.setup(*attributes);
+        attributeSpecsBuilder.setup(*attributes, SummarymapConfig());
         return DocumentDBConfig::SP(new DocumentDBConfig(
                         1,
                         std::make_shared<RankProfilesConfig>(),
@@ -123,7 +123,7 @@ public:
                         attributeSpecsBuilder.getAttributesConfig(),
                         attributeSpecsBuilder.getAttributeSpecs(),
                         summary,
-                        std::make_shared<SummarymapConfig>(),
+                        attributeSpecsBuilder.getSummarymapConfig(),
                         std::make_shared<JuniperrcConfig>(),
                         _typeCfg,
                         _repo,
diff --git a/searchcore/src/tests/proton/attribute/attribute_specs_builder/attribute_specs_builder_test.cpp b/searchcore/src/tests/proton/attribute/attribute_specs_builder/attribute_specs_builder_test.cpp
index 59756d377da..585ffc88414 100644
--- a/searchcore/src/tests/proton/attribute/attribute_specs_builder/attribute_specs_builder_test.cpp
+++ b/searchcore/src/tests/proton/attribute/attribute_specs_builder/attribute_specs_builder_test.cpp
@@ -12,11 +12,14 @@ LOG_SETUP("attribute_specs_builder_test");
 #include <vespa/vespalib/test/insertion_operators.h>
 #include <vespa/config-indexschema.h>
 #include <vespa/config-attributes.h>
+#include <vespa/config-summarymap.h>
 
 using vespa::config::search::AttributesConfig;
 using vespa::config::search::AttributesConfigBuilder;
 using vespa::config::search::IndexschemaConfig;
 using vespa::config::search::IndexschemaConfigBuilder;
+using vespa::config::search::SummarymapConfig;
+using vespa::config::search::SummarymapConfigBuilder;
 using search::attribute::Config;
 using search::attribute::BasicType;
 using search::attribute::CollectionType;
@@ -51,6 +54,12 @@ ostream &operator<<(ostream &os, const proton::AttributeSpec &spec)
     return os;
 }
 
+ostream &operator<<(ostream &os, const SummarymapConfig::Override &override)
+{
+    os << "{field=" << override.field << ", command=" << override.command << ", arguments=" << override.arguments << "}";
+    return os;
+}
+
 }
 
 namespace proton
@@ -125,6 +134,31 @@ Config getTensor(const vespalib::string &spec)
     return ret;
 }
 
+SummarymapConfig::Override make_attribute_override(const vespalib::string &name)
+{
+    SummarymapConfig::Override override;
+    override.field = name;
+    override.command = "attribute";
+    override.arguments = name;
+    return override;
+}
+
+SummarymapConfig::Override make_geopos_override(const vespalib::string &name)
+{
+    SummarymapConfig::Override override;
+    override.field = name;
+    override.command = "geopos";
+    override.arguments = name;
+    return override;
+}
+
+SummarymapConfig smCfg(std::vector<SummarymapConfig::Override> overrides)
+{
+    SummarymapConfigBuilder result;
+    result.override = overrides;
+    return result;
+}
+
 class MyInspector : public IDocumentTypeInspector
 {
     std::set<vespalib::string> _unchanged;
@@ -167,141 +201,181 @@ public:
         field.name = name;
         _oldIndexSchema.indexfield.emplace_back(field);
     }
-    void setup(const AttributesConfig &newConfig) {
-        _builder.setup(newConfig);
+    void setup(const AttributesConfig &newAttributesConfig, const SummarymapConfig &newSummarymapConfig) {
+        _builder.setup(newAttributesConfig, newSummarymapConfig);
     }
-    void setup(const AttributesConfig &oldConfig, const AttributesConfig &newConfig) {
+    void setup(const AttributesConfig &oldAttributesConfig, const SummarymapConfig &oldSummarymapConfig,
+               const AttributesConfig &newAttributesConfig, const SummarymapConfig &newSummarymapConfig) {
         IndexschemaInspector indexschemaInspector(_oldIndexSchema);
-        _builder.setup(oldConfig, newConfig, indexschemaInspector, _inspector);
+        _builder.setup(oldAttributesConfig, oldSummarymapConfig,
+                       newAttributesConfig, newSummarymapConfig,
+                       indexschemaInspector, _inspector);
     }
     void assertSpecs(const std::vector<AttributeSpec> &expSpecs)
     {
         const auto &actSpecs = _builder.getAttributeSpecs();
         EXPECT_EQUAL(expSpecs, actSpecs->getSpecs());
     }
-    void assertConfigs(const std::vector<AttributesConfig::Attribute> &exp)
+    void assertAttributeConfig(const std::vector<AttributesConfig::Attribute> &exp)
     {
         auto actConfig = _builder.getAttributesConfig();
         EXPECT_TRUE(exp == actConfig->attribute);
     }
+    void assertSummarymapConfig(const std::vector<SummarymapConfig::Override> &exp)
+    {
+        auto summarymapConfig = _builder.getSummarymapConfig();
+        EXPECT_EQUAL(exp, summarymapConfig->override);
+    }
 };
 
 TEST_F("require that empty specs is OK", Fixture)
 {
-    f.setup(attrCfg({}));
+    f.setup(attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
 }
 
 TEST_F("require that simple attribute specs is OK", Fixture)
 {
-    f.setup(attrCfg({make_int32_sv_cfg()}));
+    f.setup(attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, false, false)}));
-    TEST_DO(f.assertConfigs({make_int32_sv_cfg()}));
+    TEST_DO(f.assertAttributeConfig({make_int32_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that adding attribute aspect is delayed if field type is unchanged", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({}), attrCfg({make_int32_sv_cfg()}));
+    f.setup(attrCfg({}), smCfg({}), attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, false, true)}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
+}
+
+TEST_F("require that adding attribute aspect is delayed if field type is unchanged, geopos override", Fixture)
+{
+    f.addFields({"a"});
+    f.setup(attrCfg({}), smCfg({}), attrCfg({make_int32_sv_cfg()}), smCfg({make_geopos_override("a")}));
+    TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, false, true)}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({make_geopos_override("a")}));
 }
 
 TEST_F("require that adding attribute is not delayed if field type changed", Fixture)
 {
-    f.setup(attrCfg({}), attrCfg({make_int32_sv_cfg()}));
+    f.setup(attrCfg({}), smCfg({}), attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, false, false)}));
-    TEST_DO(f.assertConfigs({make_int32_sv_cfg()}));
+    TEST_DO(f.assertAttributeConfig({make_int32_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that removing attribute aspect is delayed if field type is unchanged", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_int32_sv_cfg()}), attrCfg({}));
+    f.setup(attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}), attrCfg({}), smCfg({}));
+    TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, true, false)}));
+    TEST_DO(f.assertAttributeConfig({make_int32_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
+}
+
+TEST_F("require that removing attribute aspect is delayed if field type is unchanged, gepos override", Fixture)
+{
+    f.addFields({"a"});
+    f.setup(attrCfg({make_int32_sv_cfg()}), smCfg({make_geopos_override("a")}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv, true, false)}));
-    TEST_DO(f.assertConfigs({make_int32_sv_cfg()}));
+    TEST_DO(f.assertAttributeConfig({make_int32_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that removing attribute aspect is not delayed if field type changed", Fixture)
 {
-    f.setup(attrCfg({make_int32_sv_cfg()}), attrCfg({}));
+    f.setup(attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that removing attribute aspect is not delayed if also indexed", Fixture)
 {
     f.addFields({"a"});
     f.addOldIndexField("a");
-    f.setup(attrCfg({make_string_sv_cfg()}), attrCfg({}));
+    f.setup(attrCfg({make_string_sv_cfg()}), smCfg({make_attribute_override("a")}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that removing attribute aspect is not delayed for tensor", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_tensor_cfg("tensor(x[10])")}), attrCfg({}));
+    f.setup(attrCfg({make_tensor_cfg("tensor(x[10])")}), smCfg({make_attribute_override("a")}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that removing attribute aspect is not delayed for predicate", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_predicate_cfg(4)}), attrCfg({}));
+    f.setup(attrCfg({make_predicate_cfg(4)}), smCfg({}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that removing attribute aspect is not delayed for reference", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_reference_cfg()}), attrCfg({}));
+    f.setup(attrCfg({make_reference_cfg()}), smCfg({}), attrCfg({}), smCfg({}));
     TEST_DO(f.assertSpecs({}));
-    TEST_DO(f.assertConfigs({}));
+    TEST_DO(f.assertAttributeConfig({}));
+    TEST_DO(f.assertSummarymapConfig({}));
 }
 
 TEST_F("require that fast access flag change is delayed, false->true edge", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_int32_sv_cfg()}), attrCfg({make_fa(make_int32_sv_cfg())}));
+    f.setup(attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}), attrCfg({make_fa(make_int32_sv_cfg())}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", int32_sv)}));
-    TEST_DO(f.assertConfigs({make_int32_sv_cfg()}));
+    TEST_DO(f.assertAttributeConfig({make_int32_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that fast access flag change is delayed, true->false edge", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_fa(make_int32_sv_cfg())}), attrCfg({make_int32_sv_cfg()}));
+    f.setup(attrCfg({make_fa(make_int32_sv_cfg())}), smCfg({make_attribute_override("a")}), attrCfg({make_int32_sv_cfg()}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", make_fa(int32_sv))}));
-    TEST_DO(f.assertConfigs({make_fa(make_int32_sv_cfg())}));
+    TEST_DO(f.assertAttributeConfig({make_fa(make_int32_sv_cfg())}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that fast access flag change is delayed, false->true edge, tensor attr", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_tensor_cfg("tensor(x[10])")}), attrCfg({make_fa(make_tensor_cfg("tensor(x[10])"))}));
+    f.setup(attrCfg({make_tensor_cfg("tensor(x[10])")}), smCfg({make_attribute_override("a")}), attrCfg({make_fa(make_tensor_cfg("tensor(x[10])"))}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", getTensor("tensor(x[10])"))}));
-    TEST_DO(f.assertConfigs({make_tensor_cfg("tensor(x[10])")}));
+    TEST_DO(f.assertAttributeConfig({make_tensor_cfg("tensor(x[10])")}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that fast access flag change is not delayed, true->false edge, tensor attr", Fixture)
 {
     f.addFields({"a"});
-    f.setup(attrCfg({make_fa(make_tensor_cfg("tensor(x[10])"))}), attrCfg({make_tensor_cfg("tensor(x[10])")}));
+    f.setup(attrCfg({make_fa(make_tensor_cfg("tensor(x[10])"))}), smCfg({make_attribute_override("a")}), attrCfg({make_tensor_cfg("tensor(x[10])")}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", getTensor("tensor(x[10])"))}));
-    TEST_DO(f.assertConfigs({make_tensor_cfg("tensor(x[10])")}));
+    TEST_DO(f.assertAttributeConfig({make_tensor_cfg("tensor(x[10])")}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 TEST_F("require that fast access flag change is not delayed, true->false edge, string attribute, indexed field", Fixture)
 {
     f.addFields({"a"});
     f.addOldIndexField("a");
-    f.setup(attrCfg({make_fa(make_string_sv_cfg())}), attrCfg({make_string_sv_cfg()}));
+    f.setup(attrCfg({make_fa(make_string_sv_cfg())}), smCfg({make_attribute_override("a")}), attrCfg({make_string_sv_cfg()}), smCfg({make_attribute_override("a")}));
     TEST_DO(f.assertSpecs({AttributeSpec("a", string_sv, false, false)}));
-    TEST_DO(f.assertConfigs({make_string_sv_cfg()}));
+    TEST_DO(f.assertAttributeConfig({make_string_sv_cfg()}));
+    TEST_DO(f.assertSummarymapConfig({make_attribute_override("a")}));
 }
 
 }
diff --git a/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp b/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
index 2ddb1752d24..19abad7ed03 100644
--- a/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
+++ b/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
@@ -73,7 +73,7 @@ struct DBConfigFixture {
                                    const vespalib::string &docTypeName)
     {
         AttributeSpecsBuilder attributeSpecsBuilder;
-        attributeSpecsBuilder.setup(_attributesBuilder);
+        attributeSpecsBuilder.setup(_attributesBuilder, _summarymapBuilder);
         return std::make_shared<DocumentDBConfig>
             (generation,
              std::make_shared<RankProfilesConfig>(_rankProfilesBuilder),
@@ -82,7 +82,7 @@ struct DBConfigFixture {
              attributeSpecsBuilder.getAttributesConfig(),
              attributeSpecsBuilder.getAttributeSpecs(),
              std::make_shared<SummaryConfig>(_summaryBuilder),
-             std::make_shared<SummarymapConfig>(_summarymapBuilder),
+             attributeSpecsBuilder.getSummarymapConfig(),
              std::make_shared<JuniperrcConfig>(_juniperrcBuilder),
              documentTypes,
              repo,
diff --git a/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.cpp b/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.cpp
index 6ee6d0e7873..9abb02cf2f7 100644
--- a/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.cpp
+++ b/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.cpp
@@ -5,12 +5,16 @@
 #include <vespa/searchcore/proton/common/i_document_type_inspector.h>
 #include <vespa/searchcore/proton/common/i_indexschema_inspector.h>
 #include <vespa/searchcore/proton/common/config_hash.hpp>
+#include <vespa/vespalib/stllike/hash_set.hpp>
 #include <vespa/config-attributes.h>
+#include <vespa/config-summarymap.h>
 #include "attribute_specs.h"
 
 using search::attribute::ConfigConverter;
 using vespa::config::search::AttributesConfig;
 using vespa::config::search::AttributesConfigBuilder;
+using vespa::config::search::SummarymapConfig;
+using vespa::config::search::SummarymapConfigBuilder;
 using search::attribute::BasicType;
 
 namespace proton {
@@ -38,7 +42,8 @@ bool willTriggerReprocessOnAttributeAspectRemoval(const search::attribute::Confi
 
 AttributeSpecsBuilder::AttributeSpecsBuilder()
     : _specs(std::make_shared<AttributeSpecs>()),
-      _config(std::make_shared<AttributesConfigBuilder>())
+      _attributesConfig(std::make_shared<AttributesConfigBuilder>()),
+      _summarymapConfig(std::make_shared<SummarymapConfigBuilder>())
 {
 }
 
@@ -55,17 +60,24 @@ AttributeSpecsBuilder::getAttributeSpecs() const
 std::shared_ptr<AttributeSpecsBuilder::AttributesConfig>
 AttributeSpecsBuilder::getAttributesConfig() const
 {
-    return _config;
+    return _attributesConfig;
+}
+
+std::shared_ptr<AttributeSpecsBuilder::SummarymapConfig>
+AttributeSpecsBuilder::getSummarymapConfig() const
+{
+    return _summarymapConfig;
 }
 
 void
-AttributeSpecsBuilder::setup(const AttributesConfig &newConfig)
+AttributeSpecsBuilder::setup(const AttributesConfig &newAttributesConfig, const SummarymapConfig &newSummarymapConfig)
 {
-    for (const auto &attr : newConfig.attribute) {
+    for (const auto &attr : newAttributesConfig.attribute) {
         search::attribute::Config cfg = ConfigConverter::convert(attr);
         _specs->emplace_back(attr.name, cfg);
     }
-    _config = std::make_shared<AttributesConfigBuilder>(newConfig);
+    _attributesConfig = std::make_shared<AttributesConfigBuilder>(newAttributesConfig);
+    _summarymapConfig = std::make_shared<SummarymapConfigBuilder>(newSummarymapConfig);
 }
 
 namespace {
@@ -73,18 +85,21 @@ namespace {
 void
 handleNewAttributes(const AttributesConfig &oldAttributesConfig,
                     const AttributesConfig &newAttributesConfig,
+                    const SummarymapConfig &newSummarymapConfig,
                     const IIndexschemaInspector &oldIndexschemaInspector,
                     const IDocumentTypeInspector &inspector,
                     AttributeSpecs &specs,
-                    AttributesConfigBuilder &config)
+                    AttributesConfigBuilder &attributesConfig,
+                    SummarymapConfigBuilder &summarymapConfig)
 {
+    vespalib::hash_set<vespalib::string> delayed;
     AttributesConfigHash oldAttrs(oldAttributesConfig.attribute);
     for (const auto &newAttr : newAttributesConfig.attribute) {
         search::attribute::Config newCfg = ConfigConverter::convert(newAttr);
         if (!inspector.hasUnchangedField(newAttr.name)) {
             // No reprocessing due to field type change, just use new config
             specs.emplace_back(newAttr.name, newCfg);
-            config.attribute.emplace_back(newAttr);
+            attributesConfig.attribute.emplace_back(newAttr);
         } else {
             auto oldAttr = oldAttrs.lookup(newAttr.name);
             if (oldAttr != nullptr) {
@@ -95,7 +110,7 @@ handleNewAttributes(const AttributesConfig &oldAttributesConfig,
                     specs.emplace_back(newAttr.name, newCfg);
                     auto modNewAttr = newAttr;
                     modNewAttr.fastaccess = oldAttr->fastaccess;
-                    config.attribute.emplace_back(modNewAttr);
+                    attributesConfig.attribute.emplace_back(modNewAttr);
                     // TODO: Don't delay change of fast access flag if
                     // attribute type can change without doucment field
                     // type changing (needs a smarter attribute
@@ -105,12 +120,23 @@ handleNewAttributes(const AttributesConfig &oldAttributesConfig,
                     // false when removing attribute aspect in a way that
                     // doesn't trigger reprocessing.
                     specs.emplace_back(newAttr.name, newCfg);
-                    config.attribute.emplace_back(newAttr);
+                    attributesConfig.attribute.emplace_back(newAttr);
                 }
             } else {
                 // Delay addition of attribute aspect
                 specs.emplace_back(newAttr.name, newCfg, false, true);
+                delayed.insert(newAttr.name);
+            }
+        }
+    }
+    for (const auto &override : newSummarymapConfig.override) {
+        if (override.command == "attribute") {
+            auto itr = delayed.find(override.field);
+            if (itr == delayed.end()) {
+                summarymapConfig.override.emplace_back(override);
             }
+        } else {
+            summarymapConfig.override.emplace_back(override);
         }
     }
 }
@@ -118,11 +144,14 @@ handleNewAttributes(const AttributesConfig &oldAttributesConfig,
 void
 handleOldAttributes(const AttributesConfig &oldAttributesConfig,
                     const AttributesConfig &newAttributesConfig,
+                    const SummarymapConfig &oldSummarymapConfig,
                     const IIndexschemaInspector &oldIndexschemaInspector,
                     const IDocumentTypeInspector &inspector,
                     AttributeSpecs &specs,
-                    AttributesConfigBuilder &config)
+                    AttributesConfigBuilder &attributesConfig,
+                    SummarymapConfigBuilder &summarymapConfig)
 {
+    vespalib::hash_set<vespalib::string> delayed;
     AttributesConfigHash newAttrs(newAttributesConfig.attribute);
     for (const auto &oldAttr : oldAttributesConfig.attribute) {
         search::attribute::Config oldCfg = ConfigConverter::convert(oldAttr);
@@ -133,25 +162,40 @@ handleOldAttributes(const AttributesConfig &oldAttributesConfig,
                 // reprocessing.
                 if (willTriggerReprocessOnAttributeAspectRemoval(oldCfg, oldIndexschemaInspector, oldAttr.name)) {
                     specs.emplace_back(oldAttr.name, oldCfg, true, false);
-                    config.attribute.emplace_back(oldAttr);
+                    attributesConfig.attribute.emplace_back(oldAttr);
+                    delayed.insert(oldAttr.name);
                 }
             }
         }
     }
+    for (const auto &override : oldSummarymapConfig.override) {
+        if (override.command == "attribute") {
+            auto itr = delayed.find(override.field);
+            if (itr != delayed.end()) {
+                summarymapConfig.override.emplace_back(override);
+            }
+        }
+    }
 }
 
 }
 
 void
 AttributeSpecsBuilder::setup(const AttributesConfig &oldAttributesConfig,
+                             const SummarymapConfig &oldSummarymapConfig,
                              const AttributesConfig &newAttributesConfig,
+                             const SummarymapConfig &newSummarymapConfig,
                              const IIndexschemaInspector &oldIndexschemaInspector,
                              const IDocumentTypeInspector &inspector)
 {
     handleNewAttributes(oldAttributesConfig, newAttributesConfig,
-                        oldIndexschemaInspector, inspector, *_specs, *_config);
+                        newSummarymapConfig,
+                        oldIndexschemaInspector, inspector, *_specs,
+                        *_attributesConfig, *_summarymapConfig);
     handleOldAttributes(oldAttributesConfig, newAttributesConfig,
-                        oldIndexschemaInspector, inspector, *_specs, *_config);
+                        oldSummarymapConfig,
+                        oldIndexschemaInspector, inspector, *_specs,
+                        *_attributesConfig, *_summarymapConfig);
 }
 
 } // namespace proton
diff --git a/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.h b/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.h
index 0cb8cde4400..f937c0e72a8 100644
--- a/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.h
+++ b/searchcore/src/vespa/searchcore/proton/attribute/attribute_specs_builder.h
@@ -8,6 +8,7 @@ namespace document { class DocumentType; }
 namespace vespa { namespace config { namespace search { namespace internal {
 class InternalAttributesType;
 class InternalIndexschemaType;
+class InternalSummarymapType;
 } } } }
 
 namespace proton {
@@ -26,9 +27,12 @@ class AttributeSpecsBuilder
     using AttributesConfig = const vespa::config::search::internal::InternalAttributesType;
     using DocumentType = document::DocumentType;
     using IndexschemaConfig = const vespa::config::search::internal::InternalIndexschemaType;
+    using SummarymapConfigBuilder = vespa::config::search::internal::InternalSummarymapType;
+    using SummarymapConfig = const vespa::config::search::internal::InternalSummarymapType;
 
     std::shared_ptr<AttributeSpecs> _specs;
-    std::shared_ptr<AttributesConfigBuilder> _config;
+    std::shared_ptr<AttributesConfigBuilder> _attributesConfig;
+    std::shared_ptr<SummarymapConfigBuilder> _summarymapConfig;
 
 public:
     AttributeSpecsBuilder();
@@ -38,18 +42,21 @@ public:
      * Setup called from document db config manager and document db
      * config scout.  No adjustments.
      */
-    void setup(const AttributesConfig &newConfig);
+    void setup(const AttributesConfig &newAttributesConfig, const SummarymapConfig &newSummarymapConfig);
     /*
      * Setup to avoid reprocessing, used to create adjusted document db
      * config before applying new config when system is online.
      */
     void setup(const AttributesConfig &oldAttributesConfig,
+               const SummarymapConfig &oldSummarymapConfig,
                const AttributesConfig &newAttributesConfig,
+               const SummarymapConfig &newSummarymapConfig,
                const IIndexschemaInspector &oldIndexschemaInspector,
                const IDocumentTypeInspector &inspector);
 
     std::shared_ptr<const AttributeSpecs> getAttributeSpecs() const;
     std::shared_ptr<AttributesConfig> getAttributesConfig() const;
+    std::shared_ptr<SummarymapConfig> getSummarymapConfig() const;
 };
 
 } // namespace proton
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
index 0537f479fed..da17ca3fdf6 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
@@ -270,7 +270,7 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
     }
     ConfigSnapshot extraConfigs(snapshot.subset(_extraConfigKeys));
     AttributeSpecsBuilder attributeSpecsBuilder;
-    attributeSpecsBuilder.setup(*newAttributesConfig);
+    attributeSpecsBuilder.setup(*newAttributesConfig, *newSummarymapConfig);
     DocumentDBConfig::SP newSnapshot(
             new DocumentDBConfig(generation,
                                  newRankProfilesConfig,
@@ -279,7 +279,7 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
                                  attributeSpecsBuilder.getAttributesConfig(),
                                  attributeSpecsBuilder.getAttributeSpecs(),
                                  newSummaryConfig,
-                                 newSummarymapConfig,
+                                 attributeSpecsBuilder.getSummarymapConfig(),
                                  newJuniperrcConfig,
                                  _bootstrapConfig->getDocumenttypesConfigSP(),
                                  _bootstrapConfig->getDocumentTypeRepoSP(),
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigscout.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigscout.cpp
index d641802aea2..c9329f893dc 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigscout.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigscout.cpp
@@ -21,7 +21,7 @@ DocumentDBConfigScout::scout(const DocumentDBConfig::SP &config,
     if (*ac == config->getAttributesConfig())
         return config; // no change
     AttributeSpecsBuilder attributeSpecsBuilder;
-    attributeSpecsBuilder.setup(*ac);
+    attributeSpecsBuilder.setup(*ac, config->getSummarymapConfig());
     return config->newFromAttributesConfig(attributeSpecsBuilder.getAttributesConfig(),
                                            attributeSpecsBuilder.getAttributeSpecs());
 }
diff --git a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
index 62e3c55903d..47955993ffd 100644
--- a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
+++ b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
@@ -75,7 +75,7 @@ DocumentDBConfig::SP
 DocumentDBConfigBuilder::build()
 {
     AttributeSpecsBuilder attributeSpecsBuilder;
-    attributeSpecsBuilder.setup(*_attributes);
+    attributeSpecsBuilder.setup(*_attributes, *_summarymap);
     return std::make_shared<DocumentDBConfig>(
             _generation,
             _rankProfiles,
@@ -84,7 +84,7 @@ DocumentDBConfigBuilder::build()
             attributeSpecsBuilder.getAttributesConfig(),
             attributeSpecsBuilder.getAttributeSpecs(),
             _summary,
-            _summarymap,
+            attributeSpecsBuilder.getSummarymapConfig(),
             _juniperrc,
             _documenttypes,
             _repo,