From 81080908f805fb6f598fab45c7b5634bbb501555 Mon Sep 17 00:00:00 2001 From: Florine de Geus Date: Tue, 13 Oct 2026 15:36:49 +0200 Subject: [PATCH] [ntuple] Change `CreateJoin` factory to free function Temporarily, so we can keep the RNTupleJoinProcessor in Experimental for a bit longer, and take the rest out already. Once the RNTupleJoinProcessor moves out of Experimental, this change should be reverted. --- tree/ntuple/inc/ROOT/RNTupleProcessor.hxx | 78 +++++++++++--------- tree/ntuple/src/RNTupleProcessor.cxx | 20 ++--- tree/ntuple/test/ntuple_processor.cxx | 70 +++++++++--------- tree/ntuple/test/ntuple_processor_join.cxx | 31 ++++---- tutorials/io/ntuple/ntpl015_processor_join.C | 4 +- 5 files changed, 106 insertions(+), 97 deletions(-) diff --git a/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx b/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx index 6403770e62909..a78900948d785 100644 --- a/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx +++ b/tree/ntuple/inc/ROOT/RNTupleProcessor.hxx @@ -31,6 +31,7 @@ namespace ROOT { namespace Experimental { +class RNTupleProcessor; namespace Internal { struct RNTupleProcessorEntryLoader; @@ -245,6 +246,44 @@ public: void Bind(std::shared_ptr valuePtr) { fProcessorEntry->Bind(fFieldIndex, std::move(valuePtr)); } }; +///////////////////////////////////////////////////////////////////////////// +/// \brief Create an RNTupleProcessor for a *join* (i.e., a horizontal combination) of RNTuples. +/// +/// \param[in] primaryNTuple The name and location of the primary RNTuple. Its entries are processed in sequential +/// order. +/// \param[in] auxNTuple The name and location of the RNTuple to join the primary RNTuple with. The order in which +/// its entries are processed is determined by the primary RNTuple and doesn't necessarily have to be sequential. +/// \param[in] joinFields The names of the fields on which to join, in case the specified RNTuples are unaligned. +/// The join is made based on the combined join field values, and therefore each field has to be present in each +/// specified RNTuple. If an empty list is provided, it is assumed that the specified ntuple are fully aligned. +/// \param[in] opts Options for the processor. +/// +/// \return A pointer to the newly created RNTupleProcessor. +// TODO(fdegeus) Move back to RNTupleProcessor::CreateJoin once RNTupleProcessor moves out of Experimental. +std::unique_ptr +CreateRNTupleJoinProcessor(RNTupleOpenSpec primaryNTuple, RNTupleOpenSpec auxNTuple, + const std::vector &joinFields, + const RNTupleProcessorOptions &opts = RNTupleProcessorOptions()); + +///////////////////////////////////////////////////////////////////////////// +/// \brief Create an RNTupleProcessor for a *join* (i.e., a horizontal combination) of RNTuples. +/// +/// \param[in] primaryProcessor The primary processor. Its entries are processed in sequential order. +/// \param[in] auxProcessor The processor to join the primary processor with. The order in which its entries are +/// processed is determined by the primary processor and doesn't necessarily have to be sequential. +/// \param[in] joinFields The names of the fields on which to join, in case the specified processors are unaligned. +/// The join is made based on the combined join field values, and therefore each field has to be present in each +/// specified processors. If an empty list is provided, it is assumed that the specified processors are fully +/// aligned. +/// \param[in] opts Options for the processor. +/// +/// \return A pointer to the newly created RNTupleProcessor. +// TODO(fdegeus) Move back to RNTupleProcessor::CreateJoin once RNTupleProcessor moves out of Experimental. +std::unique_ptr +CreateRNTupleJoinProcessor(std::unique_ptr primaryProcessor, + std::unique_ptr auxProcessor, const std::vector &joinFields, + const RNTupleProcessorOptions &opts = RNTupleProcessorOptions()); + // clang-format off /** \class ROOT::Experimental::RNTupleProcessor @@ -651,41 +690,6 @@ public: static std::unique_ptr CreateChain(std::vector> innerProcessors, const RNTupleProcessorOptions &opts = RNTupleProcessorOptions()); - - ///////////////////////////////////////////////////////////////////////////// - /// \brief Create an RNTupleProcessor for a *join* (i.e., a horizontal combination) of RNTuples. - /// - /// \param[in] primaryNTuple The name and location of the primary RNTuple. Its entries are processed in sequential - /// order. - /// \param[in] auxNTuple The name and location of the RNTuple to join the primary RNTuple with. The order in which - /// its entries are processed is determined by the primary RNTuple and doesn't necessarily have to be sequential. - /// \param[in] joinFields The names of the fields on which to join, in case the specified RNTuples are unaligned. - /// The join is made based on the combined join field values, and therefore each field has to be present in each - /// specified RNTuple. If an empty list is provided, it is assumed that the specified ntuple are fully aligned. - /// \param[in] opts Options for the processor. - /// - /// \return A pointer to the newly created RNTupleProcessor. - static std::unique_ptr CreateJoin(RNTupleOpenSpec primaryNTuple, RNTupleOpenSpec auxNTuple, - const std::vector &joinFields, - const RNTupleProcessorOptions &opts = RNTupleProcessorOptions()); - - ///////////////////////////////////////////////////////////////////////////// - /// \brief Create an RNTupleProcessor for a *join* (i.e., a horizontal combination) of RNTuples. - /// - /// \param[in] primaryProcessor The primary processor. Its entries are processed in sequential order. - /// \param[in] auxProcessor The processor to join the primary processor with. The order in which its entries are - /// processed is determined by the primary processor and doesn't necessarily have to be sequential. - /// \param[in] joinFields The names of the fields on which to join, in case the specified processors are unaligned. - /// The join is made based on the combined join field values, and therefore each field has to be present in each - /// specified processors. If an empty list is provided, it is assumed that the specified processors are fully - /// aligned. - /// \param[in] opts Options for the processor. - /// - /// \return A pointer to the newly created RNTupleProcessor. - static std::unique_ptr CreateJoin(std::unique_ptr primaryProcessor, - std::unique_ptr auxProcessor, - const std::vector &joinFields, - const RNTupleProcessorOptions &opts = RNTupleProcessorOptions()); }; // clang-format off @@ -909,6 +913,10 @@ public: // clang-format on class RNTupleJoinProcessor : public RNTupleProcessor { friend class RNTupleProcessor; + friend std::unique_ptr + CreateRNTupleJoinProcessor(std::unique_ptr primaryProcessor, + std::unique_ptr auxProcessor, + const std::vector &joinFields, const RNTupleProcessorOptions &opts); private: std::unique_ptr fPrimaryProcessor; diff --git a/tree/ntuple/src/RNTupleProcessor.cxx b/tree/ntuple/src/RNTupleProcessor.cxx index acb8b3e1bd4a7..dd350675bffba 100644 --- a/tree/ntuple/src/RNTupleProcessor.cxx +++ b/tree/ntuple/src/RNTupleProcessor.cxx @@ -67,9 +67,9 @@ ROOT::Experimental::RNTupleProcessor::CreateChain(std::vector -ROOT::Experimental::RNTupleProcessor::CreateJoin(RNTupleOpenSpec primaryNTuple, RNTupleOpenSpec auxNTuple, - const std::vector &joinFields, - const RNTupleProcessorOptions &options) +ROOT::Experimental::CreateRNTupleJoinProcessor(RNTupleOpenSpec primaryNTuple, RNTupleOpenSpec auxNTuple, + const std::vector &joinFields, + const RNTupleProcessorOptions &options) { if (joinFields.size() > 4) { throw RException(R__FAIL("a maximum of four join fields is allowed")); @@ -79,18 +79,18 @@ ROOT::Experimental::RNTupleProcessor::CreateJoin(RNTupleOpenSpec primaryNTuple, throw RException(R__FAIL("join fields must be unique")); } - std::unique_ptr primaryProcessor = Create(std::move(primaryNTuple), options); + std::unique_ptr primaryProcessor = RNTupleProcessor::Create(std::move(primaryNTuple), options); - std::unique_ptr auxProcessor = Create(std::move(auxNTuple)); + std::unique_ptr auxProcessor = RNTupleProcessor::Create(std::move(auxNTuple)); - return CreateJoin(std::move(primaryProcessor), std::move(auxProcessor), joinFields, options); + return CreateRNTupleJoinProcessor(std::move(primaryProcessor), std::move(auxProcessor), joinFields, options); } std::unique_ptr -ROOT::Experimental::RNTupleProcessor::CreateJoin(std::unique_ptr primaryProcessor, - std::unique_ptr auxProcessor, - const std::vector &joinFields, - const RNTupleProcessorOptions &options) +ROOT::Experimental::CreateRNTupleJoinProcessor(std::unique_ptr primaryProcessor, + std::unique_ptr auxProcessor, + const std::vector &joinFields, + const RNTupleProcessorOptions &options) { if (joinFields.size() > 4) { throw RException(R__FAIL("a maximum of four join fields is allowed")); diff --git a/tree/ntuple/test/ntuple_processor.cxx b/tree/ntuple/test/ntuple_processor.cxx index 5172776ccc9b7..ef6cb737dd270 100644 --- a/tree/ntuple/test/ntuple_processor.cxx +++ b/tree/ntuple/test/ntuple_processor.cxx @@ -5,11 +5,11 @@ #include #include - #include - #include +using ROOT::Experimental::CreateRNTupleJoinProcessor; + TEST(RNTupleProcessor, EmptyNTuple) { FileRaii fileGuard("test_ntuple_processor_empty.root"); @@ -433,9 +433,9 @@ TEST_F(RNTupleProcessorTest, ChainedJoin) { std::vector> innerProcs; innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); auto proc = RNTupleProcessor::CreateChain(std::move(innerProcs)); @@ -460,9 +460,9 @@ TEST_F(RNTupleProcessorTest, ChainedJoinUnaligned) { std::vector> innerProcs; innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[2], fFileNames[2]}, {"i"})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[2], fFileNames[2]}, {"i"})); innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[2], fFileNames[2]}, {"i"})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[2], fFileNames[2]}, {"i"})); auto proc = RNTupleProcessor::CreateChain(std::move(innerProcs)); @@ -487,9 +487,9 @@ TEST_F(RNTupleProcessorTest, ChainedJoinMissingEntries) { std::vector> innerProcs; innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i"})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i"})); innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i"})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i"})); auto proc = RNTupleProcessor::CreateChain(std::move(innerProcs)); @@ -526,7 +526,7 @@ TEST_F(RNTupleProcessorTest, JoinedChain) auto auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[1], fFileNames[1]}, {fNTupleNames[1], fFileNames[1]}}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -553,7 +553,7 @@ TEST_F(RNTupleProcessorTest, JoinedChainUnaligned) auto auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[2], fFileNames[2]}, {fNTupleNames[2], fFileNames[2]}}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {"i"}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {"i"}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -580,7 +580,7 @@ TEST_F(RNTupleProcessorTest, JoinedChainMissingEntries) auto auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[3], fFileNames[3]}, {fNTupleNames[3], fFileNames[3]}}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {"i"}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {"i"}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -679,7 +679,7 @@ TEST(RNTupleProcessor, JoinedChainCrossedEntries) RNTupleProcessor::CreateChain({{"ntuple", fileGuard1.GetPath()}, {"ntuple", fileGuard2.GetPath()}}); auto chain_auxiliary = RNTupleProcessor::CreateChain({{"ntuple_aux", fileGuard1.GetPath()}, {"ntuple_aux", fileGuard2.GetPath()}}); - auto proc = RNTupleProcessor::CreateJoin(std::move(chain_primary), std::move(chain_auxiliary), {"i"}); + auto proc = CreateRNTupleJoinProcessor(std::move(chain_primary), std::move(chain_auxiliary), {"i"}); auto x = proc->RequestField("x"); auto y = proc->RequestField("ntuple_aux.y"); @@ -696,14 +696,14 @@ TEST(RNTupleProcessor, JoinedChainCrossedEntries) TEST_F(RNTupleProcessorTest, JoinedJoinComposedPrimary) { auto primaryProc = - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); RNTupleProcessorOptions opts; opts.SetProcessorName("ntuple_aux2"); auto auxProc = RNTupleProcessor::Create({fNTupleNames[2], fFileNames[2]}, opts); opts.SetProcessorName("joined_ntuple"); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryProc), std::move(auxProc), {"i"}, opts); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryProc), std::move(auxProc), {"i"}, opts); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -729,13 +729,13 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedPrimary) TEST_F(RNTupleProcessorTest, JoinedJoinComposedPrimaryMissingEntries) { auto primaryProc = - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); RNTupleProcessorOptions opts; opts.SetProcessorName("ntuple_aux2"); auto auxProc = RNTupleProcessor::Create({fNTupleNames[3], fFileNames[3]}, opts); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryProc), std::move(auxProc), {"i"}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryProc), std::move(auxProc), {"i"}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -774,10 +774,10 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedAuxiliary) opts.SetProcessorName("ntuple_aux2"); auto auxProcIntermediate = RNTupleProcessor::Create({fNTupleNames[2], fFileNames[2]}, opts); - auto auxProc = RNTupleProcessor::CreateJoin(RNTupleProcessor::Create({fNTupleNames[1], fFileNames[1]}), - std::move(auxProcIntermediate), {"i"}); + auto auxProc = CreateRNTupleJoinProcessor(RNTupleProcessor::Create({fNTupleNames[1], fFileNames[1]}), + std::move(auxProcIntermediate), {"i"}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryProc), std::move(auxProc), {}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryProc), std::move(auxProc), {}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -809,10 +809,10 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedAuxiliaryMissingEntries) opts.SetProcessorName("ntuple_aux2"); auto auxProcIntermediate = RNTupleProcessor::Create({fNTupleNames[3], fFileNames[3]}, opts); - auto auxProc = RNTupleProcessor::CreateJoin(RNTupleProcessor::Create({fNTupleNames[1], fFileNames[1]}), - std::move(auxProcIntermediate), {"i"}); + auto auxProc = CreateRNTupleJoinProcessor(RNTupleProcessor::Create({fNTupleNames[1], fFileNames[1]}), + std::move(auxProcIntermediate), {"i"}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryProc), std::move(auxProc), {}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryProc), std::move(auxProc), {}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -847,10 +847,10 @@ TEST_F(RNTupleProcessorTest, JoinedJoinComposedAuxiliaryMissingEntries) TEST_F(RNTupleProcessorTest, JoinedJoinComposedSameName) { auto primaryProc = - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {}); auto auxProc = RNTupleProcessor::Create({fNTupleNames[2], fFileNames[2]}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryProc), std::move(auxProc), {"i"}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryProc), std::move(auxProc), {"i"}); try { proc->RequestField("ntuple_aux.z"); @@ -868,9 +868,9 @@ TEST_F(RNTupleProcessorTest, PrintStructureChainedJoin) { std::vector> innerProcs; innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); innerProcs.push_back( - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {})); auto proc = RNTupleProcessor::CreateChain(std::move(innerProcs)); @@ -895,7 +895,7 @@ TEST_F(RNTupleProcessorTest, PrintStructureJoinedChain) auto auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[1], fFileNames[1]}, {fNTupleNames[1], fFileNames[1]}}); - auto proc = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {}); + auto proc = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {}); std::ostringstream os; proc->PrintStructure(os); @@ -917,7 +917,7 @@ TEST_F(RNTupleProcessorTest, PrintStructureJoinedChainAsymmetric) RNTupleProcessor::CreateChain({{fNTupleNames[0], fFileNames[0]}, {fNTupleNames[0], fFileNames[0]}}); auto auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[1], fFileNames[1]}}); - auto proc1 = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {}); + auto proc1 = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {}); std::ostringstream os1; proc1->PrintStructure(os1); @@ -935,7 +935,7 @@ TEST_F(RNTupleProcessorTest, PrintStructureJoinedChainAsymmetric) primaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[0], fFileNames[0]}}); auxiliaryChain = RNTupleProcessor::CreateChain({{fNTupleNames[1], fFileNames[1]}, {fNTupleNames[1], fFileNames[1]}}); - auto proc2 = RNTupleProcessor::CreateJoin(std::move(primaryChain), std::move(auxiliaryChain), {}); + auto proc2 = CreateRNTupleJoinProcessor(std::move(primaryChain), std::move(auxiliaryChain), {}); std::ostringstream os2; proc2->PrintStructure(os2); @@ -1048,9 +1048,9 @@ TEST_F(GH16805ProcessorTest, JoinReading) auto joinProc = RNTupleProcessor::CreateChain(joinSpecs); - auto joinedWithJoin = RNTupleProcessor::CreateJoin(std::move(stepOneProc), std::move(joinProc), {}); + auto joinedWithJoin = CreateRNTupleJoinProcessor(std::move(stepOneProc), std::move(joinProc), {}); - auto joinedAll = RNTupleProcessor::CreateJoin(std::move(joinedWithJoin), std::move(stepZeroProc), {}); + auto joinedAll = CreateRNTupleJoinProcessor(std::move(joinedWithJoin), std::move(stepZeroProc), {}); auto stepOneBr1 = joinedAll->RequestField("stepOneBr1"); auto joinBr1 = joinedAll->RequestField("topLevelJoin.joinBr1"); @@ -1176,10 +1176,10 @@ class GH20033ProcessorTest : public testing::TestWithParam +using ROOT::Experimental::CreateRNTupleJoinProcessor; + class RNTupleJoinProcessorTest : public testing::Test { protected: const std::array fFileNames{"test_ntuple_join_processor1.root", "test_ntuple_join_processor2.root", @@ -87,7 +89,7 @@ class RNTupleJoinProcessorTest : public testing::Test { TEST_F(RNTupleJoinProcessorTest, Aligned) { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); auto i = proc->RequestField("i"); auto y = proc->RequestField>("y"); @@ -110,7 +112,7 @@ TEST_F(RNTupleJoinProcessorTest, Aligned) TEST_F(RNTupleJoinProcessorTest, IdenticalFieldNames) { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); auto iPrimary = proc->RequestField("i"); auto iAux = proc->RequestField("ntuple3.i"); @@ -152,7 +154,7 @@ TEST(RNTupleJoinProcessor, NameConflict) } } - auto proc = RNTupleProcessor::CreateJoin({"ntuple", fileGuard.GetPath()}, {"struct", fileGuard.GetPath()}, {}); + auto proc = CreateRNTupleJoinProcessor({"ntuple", fileGuard.GetPath()}, {"struct", fileGuard.GetPath()}, {}); try { proc->RequestField("struct.a"); @@ -167,7 +169,7 @@ TEST(RNTupleJoinProcessor, NameConflict) TEST_F(RNTupleJoinProcessorTest, UnalignedSingleJoinField) { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {"i"}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {"i"}); auto iPrimary = proc->RequestField("i"); auto iAux = proc->RequestField("ntuple2.i"); @@ -192,23 +194,22 @@ TEST_F(RNTupleJoinProcessorTest, UnalignedSingleJoinField) TEST_F(RNTupleJoinProcessorTest, UnalignedMultipleJoinFields) { try { - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, - {"i", "j", "k", "l", "m"}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, + {"i", "j", "k", "l", "m"}); FAIL() << "trying to create a join processor with more than four join fields should throw"; } catch (const ROOT::RException &err) { EXPECT_THAT(err.what(), testing::HasSubstr("a maximum of four join fields is allowed")); } try { - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i", "i"}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i", "i"}); FAIL() << "trying to create a join processor with duplicate join fields should throw"; } catch (const ROOT::RException &err) { EXPECT_THAT(err.what(), testing::HasSubstr("join fields must be unique")); } try { - auto proc = - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {"l"}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {"l"}); // Without registering a field, the processor won't be initialized. proc->RequestField("x"); FAIL() << "trying to use a join processor where not all join fields are present in the primary processor should " @@ -218,8 +219,8 @@ TEST_F(RNTupleJoinProcessorTest, UnalignedMultipleJoinFields) } try { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, - {"i", "j", "k"}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, + {"i", "j", "k"}); // Without registering a field, the processor won't be initialized. proc->RequestField("x"); FAIL() << "trying to use a join processor where not all join fields are present in the auxiliary processor " @@ -229,7 +230,7 @@ TEST_F(RNTupleJoinProcessorTest, UnalignedMultipleJoinFields) } auto proc = - RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i", "j", "k"}); + CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i", "j", "k"}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -249,7 +250,7 @@ TEST_F(RNTupleJoinProcessorTest, UnalignedMultipleJoinFields) TEST_F(RNTupleJoinProcessorTest, MissingEntries) { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[3], fFileNames[3]}, {"i"}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[3], fFileNames[3]}, {"i"}); auto i = proc->RequestField("i"); auto a = proc->RequestField("ntuple4.a"); @@ -293,7 +294,7 @@ TEST_F(RNTupleJoinProcessorTest, TMemFile) } } - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[0], fFileNames[0]}, {"ntuple_aux", &memFile}, {"i"}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[0], fFileNames[0]}, {"ntuple_aux", &memFile}, {"i"}); auto i = proc->RequestField("i"); auto x = proc->RequestField("x"); @@ -316,7 +317,7 @@ TEST_F(RNTupleJoinProcessorTest, TMemFile) TEST_F(RNTupleJoinProcessorTest, PrintStructure) { - auto proc = RNTupleProcessor::CreateJoin({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); + auto proc = CreateRNTupleJoinProcessor({fNTupleNames[1], fFileNames[1]}, {fNTupleNames[2], fFileNames[2]}, {}); std::ostringstream os; proc->PrintStructure(os); diff --git a/tutorials/io/ntuple/ntpl015_processor_join.C b/tutorials/io/ntuple/ntpl015_processor_join.C index 51fb80571e86c..7164aa25b7a6a 100644 --- a/tutorials/io/ntuple/ntpl015_processor_join.C +++ b/tutorials/io/ntuple/ntpl015_processor_join.C @@ -21,8 +21,8 @@ #include // Import classes from the `Experimental` namespace for the time being. +using ROOT::Experimental::CreateRNTupleJoinProcessor; using ROOT::Experimental::RNTupleOpenSpec; -using ROOT::Experimental::RNTupleProcessor; const std::string kPrimaryNTupleName = "mainNTuple"; const std::string kMainNTuplePath = "main_ntuple.root"; @@ -84,7 +84,7 @@ void Read() // combination of field values is used. It is possible to specify up to 4 join fields. Providing an empty list of // join fields signals to the processor that all entries are aligned. auto processor = - RNTupleProcessor::CreateJoin({kPrimaryNTupleName, kMainNTuplePath}, {kAuxNTupleName, kAuxNTuplePath}, {"i"}); + CreateRNTupleJoinProcessor({kPrimaryNTupleName, kMainNTuplePath}, {kAuxNTupleName, kAuxNTuplePath}, {"i"}); // Access to the processor's fields is done by first requesting them through RNTupleProcessor::RequestField(). The // returned value can be used to read the current entry's value for that particular field. Fields from the primary