RNTupleView.cxx

Go to the documentation of this file.

/// \file RNTupleView.cxx
/// \author Jakob Blomer <jblomer@cern.ch>
/// \date 2024-10-28
 
/*************************************************************************
 * Copyright (C) 1995-2024, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include <ROOT/RError.hxx>
#include <ROOT/RFieldBase.hxx>
#include <ROOT/RNTupleDescriptor.hxx>
#include <ROOT/RNTupleView.hxx>
#include <ROOT/RPageStorage.hxx>
 
#include <deque>
 
ROOT::RNTupleGlobalRange
ROOT::Internal::GetFieldRange(const ROOT::RFieldBase &field, ROOT::Internal::RPageSource &pageSource)
{
   std::uint64_t arraySize = 1;
   DescriptorId_t columnId = ROOT::kInvalidDescriptorId;
 
   {
      auto descGuard = pageSource.GetSharedDescriptorGuard();
      const auto &desc = descGuard.GetRef();
 
      auto parentId = desc.GetFieldDescriptor(field.GetOnDiskId()).GetParentId();
      while (parentId != desc.GetFieldZeroId()) {
         const auto &fd = desc.GetFieldDescriptor(parentId);
         if ((fd.GetStructure() != ROOT::ENTupleStructure::kPlain) &&
             (fd.GetStructure() != ROOT::ENTupleStructure::kRecord)) {
            break;
         }
         parentId = fd.GetParentId();
      }
      if (parentId == desc.GetFieldZeroId()) {
         // This field is structurally a top-level field, hence we can avoid the calculation of column elements
         // and instead return the number of entries.
         return ROOT::RNTupleGlobalRange(0, desc.GetNEntries());
      }
 
      auto fnGetPrincipalColumnId = [&desc](ROOT::DescriptorId_t fieldId) -> ROOT::DescriptorId_t {
         R__ASSERT(fieldId != ROOT::kInvalidDescriptorId);
         auto columnIterable = desc.GetColumnIterable(fieldId);
         return (columnIterable.size() > 0) ? columnIterable.begin()->GetPhysicalId() : ROOT::kInvalidDescriptorId;
      };
 
      columnId = fnGetPrincipalColumnId(field.GetOnDiskId());
      if (columnId == ROOT::kInvalidDescriptorId) {
         // We need to iterate the field descriptor tree, not the sub fields of `field`, because in the presence of
         // read rules, the in-memory sub fields may be artificial and not have valid on-disk IDs.
         const auto &linkIds = desc.GetFieldDescriptor(field.GetOnDiskId()).GetLinkIds();
         std::deque<ROOT::DescriptorId_t> subFields(linkIds.begin(), linkIds.end());
         while (!subFields.empty()) {
            auto subFieldId = subFields.front();
            subFields.pop_front();
            columnId = fnGetPrincipalColumnId(subFieldId);
            if (columnId != ROOT::kInvalidDescriptorId)
               break;
 
            const auto &subLinkIds = desc.GetFieldDescriptor(subFieldId).GetLinkIds();
            subFields.insert(subFields.end(), subLinkIds.begin(), subLinkIds.end());
         }
      }
 
      if (columnId == ROOT::kInvalidDescriptorId) {
         return ROOT::RNTupleGlobalRange(ROOT::kInvalidNTupleIndex, ROOT::kInvalidNTupleIndex);
      }
 
      arraySize = std::max(arraySize, desc.GetFieldDescriptor(field.GetOnDiskId()).GetNRepetitions());
   }
 
   return ROOT::RNTupleGlobalRange(0, pageSource.GetNElements(columnId) / arraySize);
}