diff --git a/tree/dataframe/test/datasource_ntuple.cxx b/tree/dataframe/test/datasource_ntuple.cxx
index b5a64fb4820c7..9e25a83f1a060 100644
--- a/tree/dataframe/test/datasource_ntuple.cxx
+++ b/tree/dataframe/test/datasource_ntuple.cxx
@@ -455,7 +455,7 @@ TEST_F(RNTupleDSTest, AlternativeColumnTypes)
 
    auto multipleAlternativeTypes =
       df.Define("nJets", [](const std::vector<float> &jets) { return jets.size(); }, {"jets"})
-         .Define("smallestJet", [](const std::set<float> &jets) { return *(jets.begin()); }, {"jets"})
+         .Define("smallestJet", [](const std::multiset<float> &jets) { return *(jets.begin()); }, {"jets"})
          .Min<float>("smallestJet")
          .GetValue();
    EXPECT_FLOAT_EQ(1.f, multipleAlternativeTypes);
diff --git a/tree/ntuple/inc/ROOT/RField/RFieldProxiedCollection.hxx b/tree/ntuple/inc/ROOT/RField/RFieldProxiedCollection.hxx
index 9a1ed6cba5b58..fe0d63b11364c 100644
--- a/tree/ntuple/inc/ROOT/RField/RFieldProxiedCollection.hxx
+++ b/tree/ntuple/inc/ROOT/RField/RFieldProxiedCollection.hxx
@@ -154,7 +154,7 @@ protected:
    /// (Attach() and setting fItemSize)
    RProxiedCollectionField(std::string_view fieldName, TClass *classp);
 
-   std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const final;
+   std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const override;
    const RColumnRepresentations &GetColumnRepresentations() const final;
    void GenerateColumns() final;
    void GenerateColumns(const ROOT::RNTupleDescriptor &desc) final;
@@ -165,7 +165,7 @@ protected:
    std::size_t AppendImpl(const void *from) final;
    void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final;
 
-   void ReconcileOnDiskField(const RNTupleDescriptor &desc) final;
+   void ReconcileOnDiskField(const RNTupleDescriptor &desc) override;
 
    void CommitClusterImpl() final { fNWritten = 0; }
 
@@ -277,6 +277,15 @@ public:
       kMultiMap,
       kUnorderedMultiMap
    };
+
+private:
+   EMapType fMapType;
+
+protected:
+   std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const final;
+   void ReconcileOnDiskField(const RNTupleDescriptor &desc) final;
+
+public:
    RMapField(std::string_view fieldName, EMapType mapType, std::unique_ptr<RFieldBase> itemField);
    RMapField(RMapField &&other) = default;
    RMapField &operator=(RMapField &&other) = default;
@@ -364,6 +373,15 @@ public:
       kMultiSet,
       kUnorderedMultiSet
    };
+
+private:
+   ESetType fSetType;
+
+protected:
+   std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const final;
+   void ReconcileOnDiskField(const RNTupleDescriptor &desc) final;
+
+public:
    RSetField(std::string_view fieldName, ESetType setType, std::unique_ptr<RFieldBase> itemField);
    RSetField(RSetField &&other) = default;
    RSetField &operator=(RSetField &&other) = default;
diff --git a/tree/ntuple/src/RFieldMeta.cxx b/tree/ntuple/src/RFieldMeta.cxx
index aeeade9d72892..1bccf8b34cb31 100644
--- a/tree/ntuple/src/RFieldMeta.cxx
+++ b/tree/ntuple/src/RFieldMeta.cxx
@@ -880,7 +880,7 @@ void ROOT::RProxiedCollectionField::AcceptVisitor(ROOT::Detail::RFieldVisitor &v
 //------------------------------------------------------------------------------
 
 ROOT::RMapField::RMapField(std::string_view fieldName, EMapType mapType, std::unique_ptr<RFieldBase> itemField)
-   : RProxiedCollectionField(fieldName, EnsureValidClass(BuildMapTypeName(mapType, itemField.get())))
+   : RProxiedCollectionField(fieldName, EnsureValidClass(BuildMapTypeName(mapType, itemField.get()))), fMapType(mapType)
 {
    auto *itemClass = fProxy->GetValueClass();
    fItemSize = itemClass->GetClassSize();
@@ -888,15 +888,58 @@ ROOT::RMapField::RMapField(std::string_view fieldName, EMapType mapType, std::un
    Attach(std::move(itemField));
 }
 
+std::unique_ptr<ROOT::RFieldBase> ROOT::RMapField::CloneImpl(std::string_view newName) const
+{
+   return std::make_unique<RMapField>(newName, fMapType, fSubfields[0]->Clone(fSubfields[0]->GetFieldName()));
+}
+
+void ROOT::RMapField::ReconcileOnDiskField(const RNTupleDescriptor &desc)
+{
+   static const std::vector<std::string> prefixesRegular = {"std::map<", "std::unordered_map<", "std::set<",
+                                                            "std::unordered_set<"};
+
+   EnsureMatchingOnDiskField(desc, kDiffTypeName).ThrowOnError();
+
+   switch (fMapType) {
+   case EMapType::kMap:
+   case EMapType::kUnorderedMap: EnsureMatchingTypePrefix(desc, prefixesRegular).ThrowOnError(); break;
+   default:
+      break;
+      // no restrictions for multimaps
+   }
+}
+
 //------------------------------------------------------------------------------
 
 ROOT::RSetField::RSetField(std::string_view fieldName, ESetType setType, std::unique_ptr<RFieldBase> itemField)
-   : ROOT::RProxiedCollectionField(fieldName, EnsureValidClass(BuildSetTypeName(setType, *itemField)))
+   : ROOT::RProxiedCollectionField(fieldName, EnsureValidClass(BuildSetTypeName(setType, *itemField))),
+     fSetType(setType)
 {
    fItemSize = itemField->GetValueSize();
    Attach(std::move(itemField));
 }
 
+std::unique_ptr<ROOT::RFieldBase> ROOT::RSetField::CloneImpl(std::string_view newName) const
+{
+   return std::make_unique<RSetField>(newName, fSetType, fSubfields[0]->Clone(fSubfields[0]->GetFieldName()));
+}
+
+void ROOT::RSetField::ReconcileOnDiskField(const RNTupleDescriptor &desc)
+{
+   static const std::vector<std::string> prefixesRegular = {"std::set<", "std::unordered_set<", "std::map<",
+                                                            "std::unordered_map<"};
+
+   EnsureMatchingOnDiskField(desc, kDiffTypeName).ThrowOnError();
+
+   switch (fSetType) {
+   case ESetType::kSet:
+   case ESetType::kUnorderedSet: EnsureMatchingTypePrefix(desc, prefixesRegular).ThrowOnError(); break;
+   default:
+      break;
+      // no restrictions for multisets
+   }
+}
+
 //------------------------------------------------------------------------------
 
 namespace {
diff --git a/tree/ntuple/src/RFieldSequenceContainer.cxx b/tree/ntuple/src/RFieldSequenceContainer.cxx
index cd5e1cd133563..0f526a0a1b8a0 100644
--- a/tree/ntuple/src/RFieldSequenceContainer.cxx
+++ b/tree/ntuple/src/RFieldSequenceContainer.cxx
@@ -547,7 +547,7 @@ ROOT::RVectorField::RVectorField(std::string_view fieldName, std::unique_ptr<RFi
 std::unique_ptr<ROOT::RVectorField>
 ROOT::RVectorField::CreateUntyped(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField)
 {
-   return std::unique_ptr<ROOT::RVectorField>(new RVectorField(fieldName, std::move(itemField), ""));
+   return std::unique_ptr<ROOT::RVectorField>(new RVectorField(fieldName, itemField->Clone("_0"), ""));
 }
 
 std::unique_ptr<ROOT::RFieldBase> ROOT::RVectorField::CloneImpl(std::string_view newName) const
diff --git a/tree/ntuple/test/CMakeLists.txt b/tree/ntuple/test/CMakeLists.txt
index 9d090c68a1059..a31206aea57fa 100644
--- a/tree/ntuple/test/CMakeLists.txt
+++ b/tree/ntuple/test/CMakeLists.txt
@@ -38,6 +38,11 @@ ROOT_GENERATE_DICTIONARY(RNTupleDescriptorDict ${CMAKE_CURRENT_SOURCE_DIR}/RNTup
 
 ROOT_ADD_GTEST(ntuple_endian ntuple_endian.cxx LIBRARIES ROOTNTuple)
 ROOT_ADD_GTEST(ntuple_evolution_type ntuple_evolution_type.cxx LIBRARIES ROOTNTuple)
+ROOT_GENERATE_DICTIONARY(STLContainerEvolutionDict ${CMAKE_CURRENT_SOURCE_DIR}/STLContainerEvolution.hxx
+                         MODULE ntuple_evolution_type
+                         LINKDEF STLContainerEvolutionLinkDef.h
+                         OPTIONS -inlineInputHeader
+                         DEPENDENCIES CustomStruct)
 if(NOT MSVC)
   # These unit tests rely on fork(), which is not available on Windows.
   ROOT_ADD_GTEST(ntuple_evolution_shape ntuple_evolution_shape.cxx LIBRARIES ROOTNTuple)
diff --git a/tree/ntuple/test/STLContainerEvolution.hxx b/tree/ntuple/test/STLContainerEvolution.hxx
new file mode 100644
index 0000000000000..65fc69403589a
--- /dev/null
+++ b/tree/ntuple/test/STLContainerEvolution.hxx
@@ -0,0 +1,39 @@
+#ifndef ROOT_RNTuple_Test_STLContainerEvolution
+#define ROOT_RNTuple_Test_STLContainerEvolution
+
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+// The following std::hash specializations allow for creating unordered sets of pairs in the Collections test.
+// It is a quick but bad hash but for this test though it should be ok.
+template <>
+struct std::hash<std::pair<int, int>> {
+   std::size_t operator()(const std::pair<int, int> &p) const noexcept
+   {
+      std::size_t h1 = std::hash<int>{}(p.first);
+      std::size_t h2 = std::hash<int>{}(p.second);
+      return h1 ^ (h2 << 1);
+   }
+};
+
+template <>
+struct std::hash<std::pair<short int, short int>> {
+   std::size_t operator()(const std::pair<short int, short int> &p) const noexcept
+   {
+      std::size_t h1 = std::hash<short int>{}(p.first);
+      std::size_t h2 = std::hash<short int>{}(p.second);
+      return h1 ^ (h2 << 1);
+   }
+};
+
+template <typename T>
+struct CollectionProxy {
+   using ValueType = T;
+   std::vector<T> v; //!
+};
+
+#endif
diff --git a/tree/ntuple/test/STLContainerEvolutionLinkDef.h b/tree/ntuple/test/STLContainerEvolutionLinkDef.h
new file mode 100644
index 0000000000000..36fde4f9cd9da
--- /dev/null
+++ b/tree/ntuple/test/STLContainerEvolutionLinkDef.h
@@ -0,0 +1,40 @@
+#ifdef __CLING__
+
+#pragma link C++ class std::set<int>+;
+#pragma link C++ class std::set<short int>+;
+#pragma link C++ class std::set<std::pair<int, int>>+;
+#pragma link C++ class std::set<std::pair<short int, short int>>+;
+
+#pragma link C++ class std::unordered_set<int>+;
+#pragma link C++ class std::unordered_set<short int>+;
+#pragma link C++ class std::unordered_set<std::pair<int, int>>+;
+#pragma link C++ class std::unordered_set<std::pair<short int, short int>>+;
+
+#pragma link C++ class std::multiset<int>+;
+#pragma link C++ class std::multiset<short int>+;
+#pragma link C++ class std::multiset<std::pair<int, int>>+;
+#pragma link C++ class std::multiset<std::pair<short int, short int>>+;
+
+#pragma link C++ class std::unordered_multiset<int>+;
+#pragma link C++ class std::unordered_multiset<short int>+;
+#pragma link C++ class std::unordered_multiset<std::pair<int, int>>+;
+#pragma link C++ class std::unordered_multiset<std::pair<short int, short int>>+;
+
+#pragma link C++ class std::map<int, int>+;
+#pragma link C++ class std::map<short int, short int>+;
+
+#pragma link C++ class std::unordered_map<int, int>+;
+#pragma link C++ class std::unordered_map<short int, short int>+;
+
+#pragma link C++ class std::multimap<int, int>+;
+#pragma link C++ class std::multimap<short int, short int>+;
+
+#pragma link C++ class std::unordered_multimap<int, int>+;
+#pragma link C++ class std::unordered_multimap<short int, short int>+;
+
+#pragma link C++ class CollectionProxy<int>+;
+#pragma link C++ class CollectionProxy<short int>+;
+#pragma link C++ class CollectionProxy<std::pair<int, int>>+;
+#pragma link C++ class CollectionProxy<std::pair<short int, short int>>+;
+
+#endif
diff --git a/tree/ntuple/test/ntuple_evolution_type.cxx b/tree/ntuple/test/ntuple_evolution_type.cxx
index 8fcf9df075384..75ef884464ccb 100644
--- a/tree/ntuple/test/ntuple_evolution_type.cxx
+++ b/tree/ntuple/test/ntuple_evolution_type.cxx
@@ -1,4 +1,6 @@
 #include "ntuple_test.hxx"
+#include "SimpleCollectionProxy.hxx"
+#include "STLContainerEvolution.hxx"
 
 #include <memory>
 #include <new>
@@ -253,3 +255,319 @@ TEST(RNTupleEvolution, ArrayAsRVec)
    EXPECT_EQ(1, a(0)[0]);
    EXPECT_EQ(2, a(0)[1]);
 }
+
+TEST(RNTupleEvolution, NullableToVector)
+{
+   FileRaii fileGuard("test_ntuple_evolution_nullable_to_vector.root");
+   {
+      auto model = ROOT::RNTupleModel::Create();
+      auto o = model->MakeField<std::optional<int>>("o");
+      auto u = model->MakeField<std::unique_ptr<int>>("u");
+      auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
+
+      *o = 137;
+      *u = std::make_unique<int>(42);
+      writer->Fill();
+      o->reset();
+      u->reset();
+      writer->Fill();
+   }
+
+   auto reader = RNTupleReader::Open("ntpl", fileGuard.GetPath());
+   auto v1 = reader->GetView<std::vector<short int>>("o");
+   auto v2 = reader->GetView<ROOT::RVec<short int>>("o");
+   auto v3 = reader->GetView<std::vector<short int>>("u");
+   auto v4 = reader->GetView<ROOT::RVec<short int>>("u");
+   EXPECT_EQ(137, v1(0)[0]);
+   EXPECT_EQ(137, v2(0)[0]);
+   EXPECT_EQ(42, v3(0)[0]);
+   EXPECT_EQ(42, v4(0)[0]);
+   EXPECT_TRUE(v1(1).empty());
+   EXPECT_TRUE(v2(1).empty());
+   EXPECT_TRUE(v3(1).empty());
+   EXPECT_TRUE(v4(1).empty());
+}
+
+namespace {
+template <typename CollectionT, bool OfPairsT>
+void WriteCollection(std::string_view ntplName, TFile &f)
+{
+   auto model = RNTupleModel::Create();
+   auto ptrCollection = model->MakeField<CollectionT>("f");
+   auto writer = ROOT::RNTupleWriter::Append(std::move(model), ntplName, f);
+   if constexpr (OfPairsT) {
+      *ptrCollection = {{1, 2}, {3, 4}, {5, 6}};
+   } else {
+      *ptrCollection = {1, 2, 3};
+   }
+   writer->Fill();
+   ptrCollection->clear();
+   writer->Fill();
+   if constexpr (OfPairsT) {
+      *ptrCollection = {{7, 8}};
+   } else {
+      *ptrCollection = {4};
+   }
+   writer->Fill();
+}
+
+template <typename CollectionT, bool OfPairsT>
+void ReadCollection(std::string_view ntplName, std::string_view path)
+{
+   auto reader = RNTupleReader::Open(ntplName, path);
+   ASSERT_EQ(3u, reader->GetNEntries());
+
+   auto view = reader->GetView<CollectionT>("f");
+   CollectionT exp0;
+   CollectionT exp2;
+   if constexpr (OfPairsT) {
+      exp0 = {{1, 2}, {3, 4}, {5, 6}};
+      exp2 = {{7, 8}};
+   } else {
+      exp0 = {1, 2, 3};
+      exp2 = {4};
+   }
+   EXPECT_EQ(exp0.size(), view(0).size());
+   for (const auto &elem : exp0) {
+      const auto &ref = view(0);
+      EXPECT_TRUE(std::find(ref.begin(), ref.end(), elem) != ref.end());
+   }
+   EXPECT_TRUE(view(1).empty());
+   EXPECT_EQ(exp2.size(), view(2).size());
+   for (std::size_t i = 0; i < exp2.size(); ++i)
+      EXPECT_EQ(*exp2.begin(), *view(2).begin());
+}
+
+template <typename CollectionT, bool OfPairsT>
+void ReadCollectionFail(std::string_view ntplName, std::string_view path)
+{
+   auto reader = RNTupleReader::Open(ntplName, path);
+   ASSERT_EQ(3u, reader->GetNEntries());
+
+   try {
+      reader->GetView<CollectionT>("f");
+      FAIL() << "this case of automatic collection schema evolution should have failed";
+   } catch (const ROOT::RException &err) {
+      EXPECT_THAT(err.what(), testing::HasSubstr("incompatible type"));
+   }
+}
+} // anonymous namespace
+
+namespace ROOT {
+template <>
+struct IsCollectionProxy<CollectionProxy<int>> : std::true_type {};
+template <>
+struct IsCollectionProxy<CollectionProxy<short int>> : std::true_type {};
+template <>
+struct IsCollectionProxy<CollectionProxy<std::pair<int, int>>> : std::true_type {};
+template <>
+struct IsCollectionProxy<CollectionProxy<std::pair<short int, short int>>> : std::true_type {};
+} // namespace ROOT
+
+TEST(RNTupleEvolution, Collections)
+{
+   FileRaii fileGuard("test_ntuple_evolution_collections.root");
+   auto f = std::unique_ptr<TFile>(TFile::Open(fileGuard.GetPath().c_str(), "UPDATE"));
+
+   TClass::GetClass("CollectionProxy<int>")->CopyCollectionProxy(SimpleCollectionProxy<CollectionProxy<int>>());
+   TClass::GetClass("CollectionProxy<short int>")
+      ->CopyCollectionProxy(SimpleCollectionProxy<CollectionProxy<short int>>());
+   TClass::GetClass("CollectionProxy<std::pair<int, int>>")
+      ->CopyCollectionProxy(SimpleCollectionProxy<CollectionProxy<std::pair<int, int>>>());
+   TClass::GetClass("CollectionProxy<std::pair<short int, short int>>")
+      ->CopyCollectionProxy(SimpleCollectionProxy<CollectionProxy<std::pair<short int, short int>>>());
+
+   {
+      auto model = RNTupleModel::Create();
+      model->AddField(ROOT::RVectorField::CreateUntyped("f", std::make_unique<RField<int>>("x")));
+      model->Freeze();
+      auto v = std::static_pointer_cast<std::vector<int>>(model->GetDefaultEntry().GetPtr<void>("f"));
+      auto writer = ROOT::RNTupleWriter::Append(std::move(model), "untyped", *f);
+      *v = {1, 2, 3};
+      writer->Fill();
+      v->clear();
+      writer->Fill();
+      *v = {4};
+      writer->Fill();
+   }
+   {
+      auto model = RNTupleModel::Create();
+      model->AddField(ROOT::RVectorField::CreateUntyped("f", std::make_unique<RField<std::pair<int, int>>>("x")));
+      model->Freeze();
+      auto v = std::static_pointer_cast<std::vector<std::pair<int, int>>>(model->GetDefaultEntry().GetPtr<void>("f"));
+      auto writer = ROOT::RNTupleWriter::Append(std::move(model), "untypedOfPairs", *f);
+      *v = {{1, 2}, {3, 4}, {5, 6}};
+      writer->Fill();
+      v->clear();
+      writer->Fill();
+      *v = {{7, 8}};
+      writer->Fill();
+   }
+   {
+      auto model = RNTupleModel::Create();
+      auto proxy = model->MakeField<CollectionProxy<int>>("f");
+      auto writer = RNTupleWriter::Append(std::move(model), "proxy", *f);
+      proxy->v = {1, 2, 3};
+      writer->Fill();
+      proxy->v.clear();
+      writer->Fill();
+      proxy->v = {4};
+      writer->Fill();
+   }
+   {
+      auto model = RNTupleModel::Create();
+      auto proxy = model->MakeField<CollectionProxy<std::pair<int, int>>>("f");
+      auto writer = RNTupleWriter::Append(std::move(model), "proxyOfPairs", *f);
+      proxy->v = {{1, 2}, {3, 4}, {5, 6}};
+      writer->Fill();
+      proxy->v.clear();
+      writer->Fill();
+      proxy->v = {{7, 8}};
+      writer->Fill();
+   }
+
+   WriteCollection<std::vector<int>, false>("vector", *f);
+   WriteCollection<ROOT::RVec<int>, false>("rvec", *f);
+   WriteCollection<std::set<int>, false>("set", *f);
+   WriteCollection<std::unordered_set<int>, false>("unordered_set", *f);
+   WriteCollection<std::multiset<int>, false>("multiset", *f);
+   WriteCollection<std::unordered_multiset<int>, false>("unordered_multiset", *f);
+   WriteCollection<std::map<int, int>, true>("map", *f);
+   WriteCollection<std::unordered_map<int, int>, true>("unordered_map", *f);
+   WriteCollection<std::multimap<int, int>, true>("multimap", *f);
+   WriteCollection<std::unordered_multimap<int, int>, true>("unordered_multimap", *f);
+
+   WriteCollection<std::vector<std::pair<int, int>>, true>("vectorOfPairs", *f);
+   WriteCollection<ROOT::RVec<std::pair<int, int>>, true>("rvecOfPairs", *f);
+   WriteCollection<std::set<std::pair<int, int>>, true>("setOfPairs", *f);
+   WriteCollection<std::unordered_set<std::pair<int, int>>, true>("unordered_setOfPairs", *f);
+   WriteCollection<std::multiset<std::pair<int, int>>, true>("multisetOfPairs", *f);
+   WriteCollection<std::unordered_multiset<std::pair<int, int>>, true>("unordered_multisetOfPairs", *f);
+
+   // All variations written out. Now test the collection matrix.
+
+   ReadCollection<std::vector<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("rvec", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("set", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("unordered_set", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("multiset", fileGuard.GetPath());
+   ReadCollection<std::vector<short int>, false>("unordered_multiset", fileGuard.GetPath());
+   ReadCollection<std::vector<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::vector<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<std::vector<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<std::vector<std::pair<short int, short int>>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollection<ROOT::RVec<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("vector", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("set", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("unordered_set", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("multiset", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<short int>, false>("unordered_multiset", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<ROOT::RVec<std::pair<short int, short int>>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollectionFail<std::set<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollectionFail<std::set<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollectionFail<std::set<short int>, false>("vector", fileGuard.GetPath());
+   ReadCollectionFail<std::set<short int>, false>("rvec", fileGuard.GetPath());
+   ReadCollection<std::set<short int>, false>("unordered_set", fileGuard.GetPath());
+   ReadCollectionFail<std::set<short int>, false>("multiset", fileGuard.GetPath());
+   ReadCollectionFail<std::set<short int>, false>("unordered_multiset", fileGuard.GetPath());
+   ReadCollection<std::set<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::set<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollectionFail<std::set<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollectionFail<std::set<std::pair<short int, short int>>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollectionFail<std::unordered_set<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<short int>, false>("vector", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<short int>, false>("rvec", fileGuard.GetPath());
+   ReadCollection<std::unordered_set<short int>, false>("set", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<short int>, false>("multiset", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<short int>, false>("unordered_multiset", fileGuard.GetPath());
+   ReadCollection<std::unordered_set<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::unordered_set<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_set<std::pair<short int, short int>>, true>("unordered_multimap",
+                                                                                 fileGuard.GetPath());
+
+   ReadCollection<std::multiset<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("vector", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("rvec", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("unordered_set", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("set", fileGuard.GetPath());
+   ReadCollection<std::multiset<short int>, false>("unordered_multiset", fileGuard.GetPath());
+   ReadCollection<std::multiset<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::multiset<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<std::multiset<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<std::multiset<std::pair<short int, short int>>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollection<std::unordered_multiset<short int>, false>("untyped", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("proxy", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("vector", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("rvec", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("unordered_set", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("set", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<short int>, false>("multiset", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<std::pair<short int, short int>>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<std::pair<short int, short int>>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<std::pair<short int, short int>>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<std::unordered_multiset<std::pair<short int, short int>>, true>("unordered_multimap",
+                                                                                  fileGuard.GetPath());
+
+   ReadCollectionFail<std::map<short int, short int>, true>("untypedOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("proxyOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("vectorOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("rvecOfPairs", fileGuard.GetPath());
+   ReadCollection<std::map<short int, short int>, true>("setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::map<short int, short int>, true>("unordered_setOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("multisetOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("unordered_multisetOfPairs", fileGuard.GetPath());
+   ReadCollection<std::map<short int, short int>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("multimap", fileGuard.GetPath());
+   ReadCollectionFail<std::map<short int, short int>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("untypedOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("proxyOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("vectorOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("rvecOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_map<short int, short int>, true>("setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_map<short int, short int>, true>("unordered_setOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("multisetOfPairs", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("unordered_multisetOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_map<short int, short int>, true>("map", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("multimap", fileGuard.GetPath());
+   ReadCollectionFail<std::unordered_map<short int, short int>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollection<std::multimap<short int, short int>, true>("untypedOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("proxyOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("vectorOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("rvecOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("unordered_setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("multisetOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("unordered_multisetOfPairs", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<std::multimap<short int, short int>, true>("unordered_multimap", fileGuard.GetPath());
+
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("untypedOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("proxyOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("vectorOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("rvecOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("unordered_setOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("multisetOfPairs", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("unordered_multisetOfPairs",
+                                                                       fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("map", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("unordered_map", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("multimap", fileGuard.GetPath());
+   ReadCollection<std::unordered_multimap<short int, short int>, true>("unordered_multimap", fileGuard.GetPath());
+}
diff --git a/tree/ntupleutil/src/RNTupleImporter.cxx b/tree/ntupleutil/src/RNTupleImporter.cxx
index bc64a15ce42e0..3184a0959084b 100644
--- a/tree/ntupleutil/src/RNTupleImporter.cxx
+++ b/tree/ntupleutil/src/RNTupleImporter.cxx
@@ -318,8 +318,8 @@ ROOT::RResult<void> ROOT::Experimental::RNTupleImporter::PrepareSchema()
 
       c.fFieldName = "_collection" + std::to_string(iLeafCountCollection);
       auto recordField = std::make_unique<ROOT::RRecordField>("_0", std::move(c.fLeafFields));
-      c.fRecordField = recordField.get();
       auto collectionField = ROOT::RVectorField::CreateUntyped(c.fFieldName, std::move(recordField));
+      c.fRecordField = static_cast<RRecordField *>(collectionField->GetMutableSubfields()[0]);
       fModel->AddField(std::move(collectionField));
 
       // Add projected fields for all leaf count arrays