29std::uint64_t GetNewModelId()
31 static std::atomic<std::uint64_t> gLastModelId = 0;
32 return ++gLastModelId;
36std::unique_ptr<ROOT::Experimental::RNTupleModel>
38 std::string_view rightFieldPrefix)
43 auto newModel = left.
Clone();
46 if (!rightFieldPrefix.empty()) {
47 newModel->MakeCollection(std::string(rightFieldPrefix), right.
Clone());
50 newModel->AddField(
f->Clone(
f->GetFieldName()));
64 auto source = fieldMap.at(
target);
65 const bool hasCompatibleStructure =
66 (source->GetStructure() ==
target->GetStructure()) ||
68 if (!hasCompatibleStructure)
69 return R__FAIL(
"field mapping structural mismatch: " + source->GetFieldName() +
" --> " +
target->GetFieldName());
71 if (
target->GetTypeName() != source->GetTypeName())
72 return R__FAIL(
"field mapping type mismatch: " + source->GetFieldName() +
" --> " +
target->GetFieldName());
91 auto *sourceBreakPoint = fnBreakPoint(source);
93 return R__FAIL(
"unsupported field mapping (source structure)");
94 auto *targetBreakPoint = fnBreakPoint(
target);
96 return R__FAIL(
"unsupported field mapping (target structure)");
98 if (!sourceBreakPoint && !targetBreakPoint) {
102 if (sourceBreakPoint && targetBreakPoint) {
103 if (sourceBreakPoint == targetBreakPoint) {
107 if (
auto it = fieldMap.find(targetBreakPoint); it != fieldMap.end() && it->second == sourceBreakPoint) {
112 return R__FAIL(
"field mapping structure mismatch: " + source->GetFieldName() +
" --> " +
target->GetFieldName());
116 return R__FAIL(
"field mapping structure mismatch: " + source->GetFieldName() +
" --> " +
target->GetFieldName());
122 auto result = EnsureValidMapping(field.get(), fieldMap);
125 for (
const auto &
f : *field) {
126 result = EnsureValidMapping(&
f, fieldMap);
131 fFieldMap.insert(fieldMap.begin(), fieldMap.end());
139 if (
auto it = fFieldMap.find(
target); it != fFieldMap.end())
144std::unique_ptr<ROOT::Experimental::RNTupleModel::RProjectedFields>
147 auto cloneFieldZero = std::unique_ptr<RFieldZero>(
static_cast<RFieldZero *
>(
fFieldZero->Clone(
"").release()));
149 clone->fModel = newModel;
152 for (
const auto &[k,
v] : fFieldMap) {
153 for (
const auto &
f : *
clone->GetFieldZero()) {
154 if (
f.GetQualifiedFieldName() == k->GetQualifiedFieldName()) {
155 clone->fFieldMap[&
f] =
clone->fModel->FindField(
v->GetQualifiedFieldName());
164 : fWriter(
writer), fOpenChangeset(fWriter.GetUpdatableModel())
170 fOpenChangeset.fModel.Unfreeze();
173 std::swap(fOpenChangeset.fModel.fModelId, fNewModelId);
178 fOpenChangeset.fModel.Freeze();
179 std::swap(fOpenChangeset.fModel.fModelId, fNewModelId);
180 if (fOpenChangeset.IsEmpty())
183 std::swap(fOpenChangeset.fAddedFields, toCommit.fAddedFields);
184 std::swap(fOpenChangeset.fAddedProjectedFields, toCommit.fAddedProjectedFields);
185 fWriter.GetSink().UpdateSchema(toCommit, fWriter.GetNEntries());
190 auto fieldp = field.get();
191 fOpenChangeset.fModel.AddField(std::move(field));
192 fOpenChangeset.fAddedFields.emplace_back(fieldp);
197 std::function<std::string(
const std::string &)> mapping)
199 auto fieldp = field.get();
200 auto result = fOpenChangeset.fModel.AddProjectedField(std::move(field), mapping);
202 fOpenChangeset.fAddedProjectedFields.emplace_back(fieldp);
212 auto fieldNameStr = std::string(fieldName);
214 throw RException(
R__FAIL(
"field name '" + fieldNameStr +
"' already exists in NTuple model"));
235 return CreateBare(std::make_unique<RFieldZero>());
238std::unique_ptr<ROOT::Experimental::RNTupleModel>
241 auto model = std::unique_ptr<RNTupleModel>(
new RNTupleModel(std::move(fieldZero)));
242 model->fProjectedFields = std::make_unique<RProjectedFields>(model.get());
248 return Create(std::make_unique<RFieldZero>());
251std::unique_ptr<ROOT::Experimental::RNTupleModel>
254 auto model = CreateBare(std::move(fieldZero));
255 model->fDefaultEntry = std::unique_ptr<REntry>(
new REntry(model->fModelId));
261 auto cloneModel = std::unique_ptr<RNTupleModel>(
262 new RNTupleModel(std::unique_ptr<RFieldZero>(
static_cast<RFieldZero *
>(fFieldZero->Clone(
"").release()))));
263 cloneModel->fModelId = GetNewModelId();
264 cloneModel->fIsFrozen = fIsFrozen;
265 cloneModel->fFieldNames = fFieldNames;
266 cloneModel->fDescription = fDescription;
267 cloneModel->fProjectedFields = fProjectedFields->Clone(cloneModel.get());
269 cloneModel->fDefaultEntry = std::unique_ptr<REntry>(
new REntry(cloneModel->fModelId));
270 for (
const auto &
f : cloneModel->fFieldZero->GetSubFields()) {
271 cloneModel->fDefaultEntry->AddValue(
f->CreateValue());
279 if (fieldName.empty())
283 for (
auto subfieldName :
ROOT::Split(fieldName,
".")) {
285 auto it = std::find_if(subfields.begin(), subfields.end(),
286 [&](
const auto *
f) { return f->GetFieldName() == subfieldName; });
287 if (it != subfields.end()) {
303 EnsureValidFieldName(field->GetFieldName());
306 fDefaultEntry->AddValue(field->CreateValue());
307 fFieldNames.insert(field->GetFieldName());
308 fFieldZero->Attach(std::move(field));
313 std::function<std::string(
const std::string &)> mapping)
318 auto fieldName = field->GetFieldName();
321 auto sourceField = FindField(mapping(fieldName));
323 return R__FAIL(
"no such field: " + mapping(fieldName));
324 fieldMap[field.get()] = sourceField;
325 for (
const auto &subField : *field) {
326 sourceField = FindField(mapping(subField.GetQualifiedFieldName()));
328 return R__FAIL(
"no such field: " + mapping(fieldName));
329 fieldMap[&subField] = sourceField;
332 EnsureValidFieldName(fieldName);
333 auto result = fProjectedFields->Add(std::move(field), fieldMap);
337 fFieldNames.insert(fieldName);
341std::shared_ptr<ROOT::Experimental::RNTupleCollectionWriter>
343 std::unique_ptr<RNTupleModel> collectionModel)
346 EnsureValidFieldName(fieldName);
347 if (!collectionModel) {
351 auto collectionWriter = std::make_shared<RNTupleCollectionWriter>(std::move(collectionModel->fDefaultEntry));
353 auto field = std::make_unique<RCollectionField>(fieldName, collectionWriter, std::move(collectionModel->fFieldZero));
354 field->SetDescription(collectionModel->GetDescription());
357 fDefaultEntry->AddValue(field->BindValue(std::shared_ptr<void>(collectionWriter->GetOffsetPtr(), [](
void *) {})));
359 fFieldNames.insert(field->GetFieldName());
360 fFieldZero->Attach(std::move(field));
361 return collectionWriter;
367 throw RException(
R__FAIL(
"invalid attempt to get mutable zero field of unfrozen model"));
373 auto f = FindField(fieldName);
383 return *fDefaultEntry;
389 throw RException(
R__FAIL(
"invalid attempt to get default entry of unfrozen model"));
391 return *fDefaultEntry;
399 auto entry = std::unique_ptr<REntry>(
new REntry(fModelId));
400 for (
const auto &
f : fFieldZero->GetSubFields()) {
401 entry->AddValue(
f->CreateValue());
411 auto entry = std::unique_ptr<REntry>(
new REntry(fModelId));
412 for (
const auto &
f : fFieldZero->GetSubFields()) {
413 entry->AddValue(
f->BindValue(
nullptr));
421 throw RException(
R__FAIL(
"invalid attempt to get field token of unfrozen model"));
423 const auto &topLevelFields = fFieldZero->GetSubFields();
424 auto it = std::find_if(topLevelFields.begin(), topLevelFields.end(),
425 [&fieldName](
const RFieldBase *
f) { return f->GetFieldName() == fieldName; });
427 if (it == topLevelFields.end()) {
438 auto f = FindField(fieldName);
441 return f->CreateBulk();
449 fModelId = GetNewModelId();
451 fDefaultEntry->fModelId = fModelId;
463 fDescription = std::string(description);
#define R__FORWARD_ERROR(res)
Short-hand to return an RResult<T> in an error state (i.e. after checking)
#define R__FORWARD_RESULT(res)
Short-hand to return an RResult<T> value from a subroutine to the calling stack frame.
#define R__FAIL(msg)
Short-hand to return an RResult<T> in an error state; the RError is implicitly converted into RResult...
TObject * clone(const char *newname) const override
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
An artificial field that transforms an RNTuple column that contains the offset of collections into co...
The field token identifies a top-level field in this entry.
The REntry is a collection of values in an ntuple corresponding to a complete row in the data set.
Base class for all ROOT issued exceptions.
Similar to RValue but manages an array of consecutive values.
A field translates read and write calls from/to underlying columns to/from tree values.
const RFieldBase * GetParent() const
std::vector< RFieldBase * > GetSubFields()
static RResult< void > EnsureValidFieldName(std::string_view fieldName)
Check whether a given string is a valid field name.
The container field for an ntuple model, which itself has no physical representation.
Projected fields are fields whose columns are reused from existing fields.
RResult< void > EnsureValidMapping(const RFieldBase *target, const FieldMap_t &fieldMap)
Asserts that the passed field is a valid target of the source field provided in the field map.
std::unordered_map< const RFieldBase *, const RFieldBase * > FieldMap_t
The map keys are the projected target fields, the map values are the backing source fields Note that ...
const RFieldBase * GetSourceField(const RFieldBase *target) const
RResult< void > Add(std::unique_ptr< RFieldBase > field, const FieldMap_t &fieldMap)
Adds a new projected field.
std::unique_ptr< RProjectedFields > Clone(const RNTupleModel *newModel) const
The new model needs to be a clone of fModel.
RUpdater(RNTupleWriter &writer)
void CommitUpdate()
Commit changes since the last call to BeginUpdate().
void BeginUpdate()
Begin a new set of alterations to the underlying model.
RResult< void > AddProjectedField(std::unique_ptr< RFieldBase > field, std::function< std::string(const std::string &)> mapping)
void AddField(std::unique_ptr< RFieldBase > field)
The RNTupleModel encapulates the schema of an ntuple.
std::unordered_set< std::string > fFieldNames
Keeps track of which field names are taken, including projected field names.
void EnsureValidFieldName(std::string_view fieldName)
Checks that user-provided field names are valid in the context of this NTuple model.
std::uint64_t fModelId
Every model has a unique ID to distinguish it from other models.
REntry::RFieldToken GetToken(std::string_view fieldName) const
Creates a token to be used in REntry methods to address a top-level field.
RResult< void > AddProjectedField(std::unique_ptr< RFieldBase > field, std::function< std::string(const std::string &)> mapping)
Adds a top-level field based on existing fields.
void EnsureNotBare() const
Throws an RException if fDefaultEntry is nullptr.
std::unique_ptr< RNTupleModel > Clone() const
void EnsureNotFrozen() const
Throws an RException if fFrozen is true.
REntry & GetDefaultEntry()
std::shared_ptr< RNTupleCollectionWriter > MakeCollection(std::string_view fieldName, std::unique_ptr< RNTupleModel > collectionModel)
Ingests a model for a sub collection and attaches it to the current model.
const RFieldBase & GetField(std::string_view fieldName) const
std::unique_ptr< REntry > CreateBareEntry() const
In a bare entry, all values point to nullptr.
std::unique_ptr< REntry > CreateEntry() const
RFieldBase::RBulk CreateBulk(std::string_view fieldName) const
Calls the given field's CreateBulk() method. Throws an exception if no field with the given name exis...
static std::unique_ptr< RNTupleModel > Create()
void SetDescription(std::string_view description)
std::unique_ptr< REntry > fDefaultEntry
Contains field values corresponding to the created top-level fields.
RFieldBase * FindField(std::string_view fieldName) const
The field name can be a top-level field or a nested field. Returns nullptr if the field is not in the...
RNTupleModel(std::unique_ptr< RFieldZero > fieldZero)
static std::unique_ptr< RNTupleModel > CreateBare()
A bare model has no default entry.
void AddField(std::unique_ptr< RFieldBase > field)
Adds a field whose type is not known at compile time.
RFieldZero & GetFieldZero()
Non-const access to the root field is used to commit clusters during writing and to set the on-disk f...
std::unique_ptr< RFieldZero > fFieldZero
Hierarchy of fields consisting of simple types and collections (sub trees)
An RNTuple that gets filled with entries (data) and writes them to storage.
void Throw()
Throws an RException with fError.
The class is used as a return type for operations that can fail; wraps a value of type T or an RError...
std::unique_ptr< RNTupleModel > MergeModels(const RNTupleModel &left, const RNTupleModel &right, std::string_view rightFieldPrefix="")
Merge two RNTuple models.
std::vector< std::string > Split(std::string_view str, std::string_view delims, bool skipEmpty=false)
Splits a string at each character in delims.
The incremental changes to a RNTupleModel