Project
Loading...
Searching...
No Matches
ASoA.h
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
12#ifndef O2_FRAMEWORK_ASOA_H_
13#define O2_FRAMEWORK_ASOA_H_
14
15#include "Framework/Pack.h"
17#include "Headers/DataHeader.h"
20#include "Framework/Traits.h"
26#include <arrow/table.h>
27#include <arrow/array.h>
28#include <arrow/util/config.h>
29#include <gandiva/selection_vector.h>
30#include <array>
31#include <cassert>
32#include <fmt/format.h>
33#include <concepts>
34#include <cstring>
35#include <gsl/span>
36#include <limits>
37
38namespace o2::framework
39{
40using ListVector = std::vector<std::vector<int64_t>>;
41
42std::string cutString(std::string&& str);
43std::string strToUpper(std::string&& str);
44} // namespace o2::framework
45
46namespace o2::soa
47{
48void accessingInvalidIndexFor(const char* getter);
49void dereferenceWithWrongType(const char* getter, const char* target);
50void missingFilterDeclaration(int hash, int ai);
51void notBoundTable(const char* tableName);
52} // namespace o2::soa
53
54namespace o2::soa
55{
57struct TableRef {
58 consteval TableRef()
59 : label_hash{0},
60 desc_hash{0},
61 origin_hash{0},
62 version{0}
63 {
64 }
65 consteval TableRef(uint32_t _label, uint32_t _desc, uint32_t _origin, uint32_t _version)
66 : label_hash{_label},
67 desc_hash{_desc},
68 origin_hash{_origin},
69 version{_version}
70 {
71 }
72 uint32_t label_hash;
73 uint32_t desc_hash;
74 uint32_t origin_hash;
75 uint32_t version;
76
77 constexpr bool operator==(TableRef const& other) const noexcept
78 {
79 return (this->label_hash == other.label_hash) &&
80 (this->desc_hash == other.desc_hash) &&
81 (this->origin_hash == other.origin_hash) &&
82 (this->version == other.version);
83 }
84
85 constexpr bool descriptionCompatible(TableRef const& other) const noexcept
86 {
87 return this->desc_hash == other.desc_hash;
88 }
89
90 constexpr bool descriptionCompatible(uint32_t _desc_hash) const noexcept
91 {
92 return this->desc_hash == _desc_hash;
93 }
94
95 constexpr TableRef(TableRef const&) = default;
96 constexpr TableRef& operator=(TableRef const&) = default;
97 constexpr TableRef(TableRef&&) = default;
98 constexpr TableRef& operator=(TableRef&&) = default;
99};
100
102template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2>
103consteval auto merge()
104{
105 constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
106 std::array<TableRef, N1 + N2 - duplicates> out;
107
108 auto pos = std::copy(ar1.begin(), ar1.end(), out.begin());
109 std::copy_if(ar2.begin(), ar2.end(), pos, [&](TableRef const& a) { return std::none_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
110 return out;
111}
112
113template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2, typename L>
114consteval auto merge_if(L l)
115{
116 constexpr const int to_remove = std::ranges::count_if(ar1.begin(), ar1.end(), [&](TableRef const& a) { return !l(a); });
117 constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }) || !l(a); });
118 std::array<TableRef, N1 + N2 - duplicates - to_remove> out;
119
120 auto pos = std::copy_if(ar1.begin(), ar1.end(), out.begin(), [&](TableRef const& a) { return l(a); });
121 std::copy_if(ar2.begin(), ar2.end(), pos, [&](TableRef const& a) { return std::none_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }) && l(a); });
122 return out;
123}
124
125template <size_t N, std::array<TableRef, N> ar, typename L>
126consteval auto remove_if(L l)
127{
128 constexpr const int to_remove = std::ranges::count_if(ar.begin(), ar.end(), [&l](TableRef const& e) { return l(e); });
129 std::array<TableRef, N - to_remove> out;
130 std::copy_if(ar.begin(), ar.end(), out.begin(), [&l](TableRef const& e) { return !l(e); });
131 return out;
132}
133
134template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2>
135consteval auto intersect()
136{
137 constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
138 std::array<TableRef, duplicates> out;
139 std::copy_if(ar1.begin(), ar1.end(), out.begin(), [](TableRef const& a) { return std::find(ar2.begin(), ar2.end(), a) != ar2.end(); });
140 return out;
141}
142
143template <typename T, typename... Ts>
144consteval auto mergeOriginals()
145 requires(sizeof...(Ts) == 1)
146{
148 return merge<T::originals.size(), T1::originals.size(), T::originals, T1::originals>();
149}
150
151template <typename T, typename... Ts>
152consteval auto mergeOriginals()
153 requires(sizeof...(Ts) > 1)
154{
155 constexpr auto tail = mergeOriginals<Ts...>();
156 return merge<T::originals.size(), tail.size(), T::originals, tail>();
157}
158
159template <typename T, typename... Ts>
160 requires(sizeof...(Ts) == 1)
161consteval auto intersectOriginals()
162{
164 return intersect<T::originals.size(), T1::originals.size(), T::originals, T1::originals>();
165}
166
167template <typename T, typename... Ts>
168 requires(sizeof...(Ts) > 1)
169consteval auto intersectOriginals()
170{
171 constexpr auto tail = intersectOriginals<Ts...>();
172 return intersect<T::originals.size(), tail.size(), T::originals, tail>();
173}
174} // namespace o2::soa
175
176namespace o2::soa
177{
178struct Binding;
179
180template <typename T>
181concept not_void = requires { !std::same_as<T, void>; };
182
184template <typename C>
185concept is_persistent_column = requires(C c) { c.mColumnIterator; };
186
187template <typename C>
189
190template <typename C>
191using is_persistent_column_t = std::conditional_t<is_persistent_column<C>, std::true_type, std::false_type>;
192
193template <typename C>
194concept is_self_index_column = not_void<typename C::self_index_t> && std::same_as<typename C::self_index_t, std::true_type>;
195
196template <typename C>
198 { c.setCurrentRaw(b) } -> std::same_as<bool>;
199 requires std::same_as<decltype(c.mBinding), o2::soa::Binding>;
200};
201
202template <typename C>
203using is_external_index_t = typename std::conditional_t<is_index_column<C>, std::true_type, std::false_type>;
204
205template <typename C>
206using is_self_index_t = typename std::conditional_t<is_self_index_column<C>, std::true_type, std::false_type>;
207} // namespace o2::soa
208
209namespace o2::aod
210{
212template <typename D, typename... Cs>
214 using columns = framework::pack<Cs...>;
218
219 template <typename Key, typename... PCs>
220 static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
221 {
222 return std::array<bool, sizeof...(PCs)>{[]() {
223 if constexpr (requires { PCs::index_targets.size(); }) {
224 return Key::template isIndexTargetOf<PCs::index_targets.size(), PCs::index_targets>();
225 } else {
226 return false;
227 }
228 }()...};
229 }
230
231 template <typename Key>
232 static consteval int getIndexPosToKey()
233 {
235 }
236
237 template <typename Key, size_t N, std::array<bool, N> map>
238 static consteval int getIndexPosToKey_impl()
239 {
240 constexpr const auto pos = std::find(map.begin(), map.end(), true);
241 if constexpr (pos != map.end()) {
242 return std::distance(map.begin(), pos);
243 } else {
244 return -1;
245 }
246 }
247};
248
249template <typename D>
251 using metadata = void;
252};
253
256template <uint32_t H>
257struct Hash {
258 static constexpr uint32_t hash = H;
259 static constexpr char const* const str{""};
260};
261
263template <size_t N, std::array<soa::TableRef, N> ar, typename Key>
264consteval auto filterForKey()
265{
266 constexpr std::array<bool, N> test = []<size_t... Is>(std::index_sequence<Is...>) {
267 return std::array<bool, N>{(Key::template hasOriginal<ar[Is]>() || (o2::aod::MetadataTrait<o2::aod::Hash<ar[Is].desc_hash>>::metadata::template getIndexPosToKey<Key>() >= 0))...};
268 }(std::make_index_sequence<N>());
269 constexpr int correct = std::ranges::count(test.begin(), test.end(), true);
270 std::array<soa::TableRef, correct> out;
271 std::ranges::copy_if(ar.begin(), ar.end(), out.begin(), [&test](soa::TableRef const& r) { return test[std::distance(ar.begin(), std::find(ar.begin(), ar.end(), r))]; });
272 return out;
273}
274
276#define O2HASH(_Str_) \
277 template <> \
278 struct Hash<_Str_ ""_h> { \
279 static constexpr uint32_t hash = _Str_ ""_h; \
280 static constexpr char const* const str{_Str_}; \
281 };
282
284#define O2ORIGIN(_Str_) \
285 template <> \
286 struct Hash<_Str_ ""_h> { \
287 static constexpr header::DataOrigin origin{_Str_}; \
288 static constexpr uint32_t hash = _Str_ ""_h; \
289 static constexpr char const* const str{_Str_}; \
290 };
291
293static inline constexpr uint32_t version(const char* const str)
294{
295 if (str[0] == '\0') {
296 return 0;
297 }
298 size_t len = 0;
299 uint32_t res = 0;
300 while (str[len] != '/' && str[len] != '\0') {
301 ++len;
302 }
303 if (str[len - 1] == '\0') {
304 return -1;
305 }
306 for (auto i = len + 1; str[i] != '\0'; ++i) {
307 res = res * 10 + (int)(str[i] - '0');
308 }
309 return res;
310}
311
313static inline constexpr std::string_view description_str(const char* const str)
314{
315 size_t len = 0;
316 while (len < 15 && str[len] != '/') {
317 ++len;
318 }
319 return std::string_view{str, len};
320}
321
322static inline constexpr header::DataDescription description(const char* const str)
323{
324 size_t len = 0;
325 while (len < 15 && str[len] != '/') {
326 ++len;
327 }
328 char out[16];
329 for (auto i = 0; i < 16; ++i) {
330 out[i] = 0;
331 }
332 std::memcpy(out, str, len);
333 return {out};
334}
335
336// Helpers to get strings from TableRef
337template <soa::TableRef R>
338consteval const char* label()
339{
340 return o2::aod::Hash<R.label_hash>::str;
341}
342
343template <soa::TableRef R>
344consteval const char* origin_str()
345{
346 return o2::aod::Hash<R.origin_hash>::str;
347}
348
349template <soa::TableRef R>
351{
352 return o2::aod::Hash<R.origin_hash>::origin;
353}
354
355template <soa::TableRef R>
356consteval const char* signature()
357{
358 return o2::aod::Hash<R.desc_hash>::str;
359}
360
362template <typename T>
363concept is_aod_hash = requires(T t) { t.hash; t.str; };
364
365template <typename T>
366concept is_origin_hash = is_aod_hash<T> && requires(T t) { t.origin; };
367
369template <soa::TableRef R>
370static constexpr auto sourceSpec()
371{
372 return fmt::format("{}/{}/{}/{}", label<R>(), origin_str<R>(), description_str(signature<R>()), R.version);
373}
374} // namespace o2::aod
375
376namespace o2::soa
377{
378template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... Ts>
379class Table;
380
382struct Binding {
383 void const* ptr = nullptr;
384 size_t hash = 0;
385 std::span<TableRef const> refs;
386
387 template <typename T>
388 void bind(T const* table)
389 {
390 ptr = table;
391 hash = o2::framework::TypeIdHelpers::uniqueId<T>();
392 refs = std::span{T::originals};
393 }
394
395 template <typename T>
396 T const* get() const
397 {
398 if (hash == o2::framework::TypeIdHelpers::uniqueId<T>()) {
399 return static_cast<T const*>(ptr);
400 }
401 return nullptr;
402 }
403};
404
405template <typename... C>
407{
408 return std::vector<std::shared_ptr<arrow::Field>>{C::asArrowField()...};
409}
410
411using SelectionVector = std::vector<int64_t>;
412
413template <typename T>
415
416template <typename T>
418
419template <typename T>
421
422template <typename T>
424
425template <typename T>
427
428template <typename T>
429concept has_configurable_extension = has_extension<T> && requires(T t) { typename T::configurable_t; requires std::same_as<std::true_type, typename T::configurable_t>; };
430
431template <typename T>
432concept is_spawnable_column = std::same_as<typename T::spawnable_t, std::true_type>;
433
434template <typename B, typename E>
436 constexpr static bool value = false;
437};
438
439template <aod::is_aod_hash A, aod::is_aod_hash B>
441 constexpr static bool value = false;
442};
443
444template <typename B, typename E>
446
447template <aod::is_aod_hash A, aod::is_aod_hash B>
449
453struct Chunked {
454 constexpr static bool chunked = true;
455};
456
459struct Flat {
460 constexpr static bool chunked = false;
461};
462
464template <typename T>
465struct unwrap {
466 using type = T;
467};
468
469template <typename T>
470struct unwrap<std::vector<T>> {
471 using type = T;
472};
473
474template <>
475struct unwrap<bool> {
476 using type = char;
477};
478
479template <typename T>
480using unwrap_t = typename unwrap<T>::type;
481
486template <typename T, typename ChunkingPolicy = Chunked>
487class ColumnIterator : ChunkingPolicy
488{
489 static constexpr char SCALE_FACTOR = std::same_as<std::decay_t<T>, bool> ? 3 : 0;
490
491 public:
496 ColumnIterator(arrow::ChunkedArray const* column)
497 : mColumn{column},
498 mCurrent{nullptr},
499 mCurrentPos{nullptr},
500 mLast{nullptr},
501 mFirstIndex{0},
502 mCurrentChunk{0},
503 mOffset{0}
504 {
505 auto array = getCurrentArray();
506 mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR);
507 mLast = mCurrent + array->length();
508 }
509
510 ColumnIterator() = default;
513
516
518 void nextChunk() const
519 {
520 auto previousArray = getCurrentArray();
521 mFirstIndex += previousArray->length();
522
524 auto array = getCurrentArray();
525 mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
526 mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
527 }
528
529 void prevChunk() const
530 {
531 auto previousArray = getCurrentArray();
532 mFirstIndex -= previousArray->length();
533
535 auto array = getCurrentArray();
536 mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
537 mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
538 }
539
540 void moveToChunk(int chunk)
541 {
542 if (mCurrentChunk < chunk) {
543 while (mCurrentChunk != chunk) {
544 nextChunk();
545 }
546 } else {
547 while (mCurrentChunk != chunk) {
548 prevChunk();
549 }
550 }
551 }
552
555 {
556 mCurrentChunk = mColumn->num_chunks() - 1;
557 auto array = getCurrentArray();
558 mFirstIndex = mColumn->length() - array->length();
559 mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
560 mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
561 }
562
563 decltype(auto) operator*() const
564 requires std::same_as<bool, std::decay_t<T>>
565 {
566 checkSkipChunk();
567 return (*(mCurrent - (mOffset >> SCALE_FACTOR) + ((*mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;
568 }
569
570 decltype(auto) operator*() const
571 requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
572 {
573 checkSkipChunk();
574 auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));
575 auto offset = list->value_offset(*mCurrentPos - mFirstIndex);
576 auto length = list->value_length(*mCurrentPos - mFirstIndex);
577 return gsl::span{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
578 }
579
580 decltype(auto) operator*() const
581 requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
582 {
583 checkSkipChunk();
584 return *(mCurrent + (*mCurrentPos >> SCALE_FACTOR));
585 }
586
587 // Move to the chunk which containts element pos
589 {
590 checkSkipChunk();
591 return *this;
592 }
593
594 mutable unwrap_t<T> const* mCurrent;
595 int64_t const* mCurrentPos;
596 mutable unwrap_t<T> const* mLast;
597 arrow::ChunkedArray const* mColumn;
598 mutable int mFirstIndex;
599 mutable int mCurrentChunk;
600 mutable int mOffset;
601
602 private:
603 void checkSkipChunk() const
604 requires((ChunkingPolicy::chunked == true) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
605 {
606 auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));
607 if (O2_BUILTIN_UNLIKELY(*mCurrentPos - mFirstIndex >= list->length())) {
608 nextChunk();
609 }
610 }
611
612 void checkSkipChunk() const
613 requires((ChunkingPolicy::chunked == true) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
614 {
615 if (O2_BUILTIN_UNLIKELY(((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) >= mLast))) {
616 nextChunk();
617 }
618 }
619
620 void checkSkipChunk() const
621 requires(ChunkingPolicy::chunked == false)
622 {
623 }
625 auto getCurrentArray() const
626 requires(std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray>)
627 {
628 std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
629 mOffset = chunkToUse->offset();
630 chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
631 return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);
632 }
633
634 auto getCurrentArray() const
635 requires(std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
636 {
637 std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
638 mOffset = chunkToUse->offset();
639 chunkToUse = std::dynamic_pointer_cast<arrow::ListArray>(chunkToUse)->values();
640 mOffset = chunkToUse->offset();
641 return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);
642 }
643
644 auto getCurrentArray() const
645 requires(!std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray> && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
646 {
647 std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
648 mOffset = chunkToUse->offset();
649 return std::static_pointer_cast<arrow_array_for_t<T>>(chunkToUse);
650 }
651};
652
653template <typename T, typename INHERIT>
654struct Column {
655 using inherited_t = INHERIT;
657 : mColumnIterator{it}
658 {
659 }
660
661 Column() = default;
662 Column(Column const&) = default;
663 Column& operator=(Column const&) = default;
664
665 Column(Column&&) = default;
666 Column& operator=(Column&&) = default;
667
668 using type = T;
669 static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
671 {
672 return mColumnIterator;
673 }
674
675 static auto asArrowField()
676 {
677 return std::make_shared<arrow::Field>(inherited_t::mLabel, framework::expressions::concreteArrowType(framework::expressions::selectArrowType<type>()));
678 }
679
683};
684
687template <typename F, typename INHERIT>
689 using inherited_t = INHERIT;
690
691 static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
692};
693
694template <typename INHERIT>
696 using inherited_t = INHERIT;
697
698 static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
699};
700
701template <typename INHERIT>
703 using inherited_t = INHERIT;
704
705 static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
706};
707
708template <size_t M = 0>
709struct Marker : o2::soa::MarkerColumn<Marker<M>> {
710 using type = size_t;
712 constexpr inline static auto value = M;
713
714 Marker() = default;
715 Marker(Marker const&) = default;
716 Marker(Marker&&) = default;
717
718 Marker& operator=(Marker const&) = default;
719 Marker& operator=(Marker&&) = default;
720
721 Marker(arrow::ChunkedArray const*) {}
722 constexpr inline auto mark()
723 {
724 return value;
725 }
726
727 static constexpr const char* mLabel = "Marker";
728};
729
730template <int64_t START = 0, int64_t END = -1>
731struct Index : o2::soa::IndexColumn<Index<START, END>> {
733 constexpr inline static int64_t start = START;
734 constexpr inline static int64_t end = END;
735
736 Index() = default;
737 Index(Index const&) = default;
738 Index(Index&&) = default;
739
740 Index& operator=(Index const&) = default;
741 Index& operator=(Index&&) = default;
742
743 Index(arrow::ChunkedArray const*)
744 {
745 }
746
747 constexpr inline int64_t rangeStart()
748 {
749 return START;
750 }
751
752 constexpr inline int64_t rangeEnd()
753 {
754 return END;
755 }
756
757 [[nodiscard]] int64_t index() const
758 {
759 return index<0>();
760 }
761
762 [[nodiscard]] int64_t filteredIndex() const
763 {
764 return index<1>();
765 }
766
767 [[nodiscard]] int64_t globalIndex() const
768 {
769 return index<0>() + offsets<0>();
770 }
771
772 template <int N = 0>
773 [[nodiscard]] int64_t index() const
774 {
775 return *std::get<N>(rowIndices);
776 }
777
778 template <int N = 0>
779 [[nodiscard]] int64_t offsets() const
780 {
781 return *std::get<N>(rowOffsets);
782 }
783
784 void setIndices(std::tuple<int64_t const*, int64_t const*> indices)
785 {
787 }
788
789 void setOffsets(std::tuple<uint64_t const*> offsets)
790 {
792 }
793
794 static constexpr const char* mLabel = "Index";
795 using type = int64_t;
796
797 std::tuple<int64_t const*, int64_t const*> rowIndices;
800 std::tuple<uint64_t const*> rowOffsets;
801};
802
803template <typename C>
804concept is_indexing_column = requires(C& c) {
805 c.rowIndices;
806 c.rowOffsets;
807};
808
809template <typename C>
810concept is_dynamic_column = requires(C& c) {
811 c.boundIterators;
812};
813
814template <typename C>
815concept is_marker_column = requires { &C::mark; };
816
817template <typename T>
818using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
819
820template <typename T>
822
823template <typename T>
824using is_indexing_t = std::conditional_t<is_indexing_column<T>, std::true_type, std::false_type>;
825
828 int64_t mRowIndex = 0;
830 uint64_t mOffset = 0;
831};
832
834 int64_t const index;
835};
836
838 // We use -1 in the IndexPolicyBase to indicate that the index is
839 // invalid. What will validate the index is the this->setCursor()
840 // which happens below which will properly setup the first index
841 // by remapping the filtered index 0 to whatever unfiltered index
842 // it belongs to.
843 FilteredIndexPolicy(gsl::span<int64_t const> selection, int64_t rows, uint64_t offset = 0)
844 : IndexPolicyBase{-1, offset},
845 mSelectedRows(selection),
846 mMaxSelection(selection.size()),
847 nRows{rows}
848 {
849 this->setCursor(0);
850 }
851
852 void resetSelection(gsl::span<int64_t const> selection)
853 {
854 mSelectedRows = selection;
855 mMaxSelection = selection.size();
856 this->setCursor(0);
857 }
858
864
865 [[nodiscard]] std::tuple<int64_t const*, int64_t const*>
867 {
868 return std::make_tuple(&mRowIndex, &mSelectionRow);
869 }
870
871 [[nodiscard]] std::tuple<uint64_t const*>
873 {
874 return std::make_tuple(&mOffset);
875 }
876
877 void limitRange(int64_t start, int64_t end)
878 {
879 this->setCursor(start);
880 if (end >= 0) {
881 mMaxSelection = std::min(end, mMaxSelection);
882 }
883 }
884
885 void setCursor(int64_t i)
886 {
887 mSelectionRow = i;
888 updateRow();
889 }
890
891 void moveByIndex(int64_t i)
892 {
893 mSelectionRow += i;
894 updateRow();
895 }
896
897 friend bool operator==(FilteredIndexPolicy const& lh, FilteredIndexPolicy const& rh)
898 {
899 return lh.mSelectionRow == rh.mSelectionRow;
900 }
901
902 bool operator==(RowViewSentinel const& sentinel) const
903 {
904 return O2_BUILTIN_UNLIKELY(mSelectionRow == sentinel.index);
905 }
906
911 {
912 this->mSelectionRow = this->mMaxSelection;
913 this->mRowIndex = -1;
914 }
915
916 [[nodiscard]] auto getSelectionRow() const
917 {
918 return mSelectionRow;
919 }
920
921 [[nodiscard]] auto size() const
922 {
923 return mMaxSelection;
924 }
925
926 [[nodiscard]] auto raw_size() const
927 {
928 return nRows;
929 }
930
931 private:
932 inline void updateRow()
933 {
934 this->mRowIndex = O2_BUILTIN_LIKELY(mSelectionRow < mMaxSelection) ? mSelectedRows[mSelectionRow] : -1;
935 }
936 gsl::span<int64_t const> mSelectedRows;
937 int64_t mSelectionRow = 0;
938 int64_t mMaxSelection = 0;
939 int64_t nRows = 0;
940};
941
949
953 DefaultIndexPolicy(int64_t nRows, uint64_t offset)
955 mMaxRow(nRows)
956 {
957 }
958
964
965 void limitRange(int64_t start, int64_t end)
966 {
967 this->setCursor(start);
968 if (end >= 0) {
969 mMaxRow = std::min(end, mMaxRow);
970 }
971 }
972
973 [[nodiscard]] std::tuple<int64_t const*, int64_t const*>
975 {
976 return std::make_tuple(&mRowIndex, &mRowIndex);
977 }
978
979 [[nodiscard]] std::tuple<uint64_t const*>
981 {
982 return std::make_tuple(&mOffset);
983 }
984
985 void setCursor(int64_t i)
986 {
987 this->mRowIndex = i;
988 }
989 void moveByIndex(int64_t i)
990 {
991 this->mRowIndex += i;
992 }
993
995 {
996 this->setCursor(mMaxRow);
997 }
998
999 friend bool operator==(DefaultIndexPolicy const& lh, DefaultIndexPolicy const& rh)
1000 {
1001 return lh.mRowIndex == rh.mRowIndex;
1002 }
1003
1004 bool operator==(RowViewSentinel const& sentinel) const
1005 {
1006 return O2_BUILTIN_UNLIKELY(this->mRowIndex == sentinel.index);
1007 }
1008
1009 [[nodiscard]] auto size() const
1010 {
1011 return mMaxRow;
1012 }
1013
1014 int64_t mMaxRow = 0;
1015};
1016
1017// template <OriginEnc ORIGIN, typename... C>
1018// class Table;
1019
1020template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... T>
1021class Table;
1022
1023template <typename T>
1025
1028template <typename C>
1031 arrow::ChunkedArray* second;
1032};
1033
1034template <typename T, typename B>
1035concept can_bind = requires(T&& t) {
1036 { t.B::mColumnIterator };
1037};
1038
1039template <typename... C>
1041
1042template <typename D, typename O, typename IP, typename... C>
1043struct TableIterator : IP, C... {
1044 public:
1045 using self_t = TableIterator<D, O, IP, C...>;
1046 using policy_t = IP;
1051 using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) -> framework::pack<typename Cs::binding_t...> {}(external_index_columns_t{})); // decltype(extractBindings(external_index_columns_t{}));
1052
1053 TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
1054 : IP{policy},
1055 C(columnData[framework::has_type_at_v<C>(all_columns{})])...
1056 {
1057 bind();
1058 }
1059
1060 TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
1061 requires(has_index<C...>)
1062 : IP{policy},
1063 C(columnData[framework::has_type_at_v<C>(all_columns{})])...
1064 {
1065 bind();
1066 // In case we have an index column might need to constrain the actual
1067 // number of rows in the view to the range provided by the index.
1068 // FIXME: we should really understand what happens to an index when we
1069 // have a RowViewFiltered.
1070 this->limitRange(this->rangeStart(), this->rangeEnd());
1071 }
1072
1073 TableIterator() = default;
1075 : IP{static_cast<IP const&>(other)},
1076 C(static_cast<C const&>(other))...
1077 {
1078 bind();
1079 }
1080
1082 {
1083 IP::operator=(static_cast<IP const&>(other));
1084 (void(static_cast<C&>(*this) = static_cast<C>(other)), ...);
1085 bind();
1086 return *this;
1087 }
1088
1090 requires std::same_as<IP, DefaultIndexPolicy>
1091 : IP{static_cast<IP const&>(other)},
1092 C(static_cast<C const&>(other))...
1093 {
1094 bind();
1095 }
1096
1098 {
1099 this->moveByIndex(1);
1100 return *this;
1101 }
1102
1104 {
1105 self_t copy = *this;
1106 this->operator++();
1107 return copy;
1108 }
1109
1111 {
1112 this->moveByIndex(-1);
1113 return *this;
1114 }
1115
1117 {
1118 self_t copy = *this;
1119 this->operator--();
1120 return copy;
1121 }
1122
1124 TableIterator operator+(int64_t inc) const
1125 {
1126 TableIterator copy = *this;
1127 copy.moveByIndex(inc);
1128 return copy;
1129 }
1130
1131 TableIterator operator-(int64_t dec) const
1132 {
1133 return operator+(-dec);
1134 }
1135
1137 {
1138 return *this;
1139 }
1140
1141 template <typename... CL, typename TA>
1143 {
1144 (CL::setCurrent(current), ...);
1145 }
1146
1147 template <typename CL>
1148 auto getCurrent() const
1149 {
1150 return CL::getCurrentRaw();
1151 }
1152
1153 template <typename... Cs>
1155 {
1156 return std::vector<o2::soa::Binding>{static_cast<Cs const&>(*this).getCurrentRaw()...};
1157 }
1158
1159 auto getIndexBindings() const
1160 {
1162 }
1163
1164 template <typename... TA>
1165 void bindExternalIndices(TA*... current)
1166 {
1168 }
1169
1170 template <typename... Cs>
1171 void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
1172 {
1173 (Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]), ...);
1174 }
1175
1176 template <typename... Cs, typename I>
1178 {
1180 b.bind(ptr);
1181 (Cs::setCurrentRaw(b), ...);
1182 }
1183
1184 void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
1185 {
1186 doSetCurrentIndexRaw(external_index_columns_t{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
1187 }
1188
1189 template <typename I>
1190 void bindInternalIndices(I const* table)
1191 {
1193 }
1194
1195 private:
1197 template <typename... PC>
1198 void doMoveToEnd(framework::pack<PC...>)
1199 {
1200 (PC::mColumnIterator.moveToEnd(), ...);
1201 }
1202
1205 void bind()
1206 {
1207 using namespace o2::soa;
1208 auto f = framework::overloaded{
1209 [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
1210 [this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },
1211 [this]<typename T>(T*) -> void {},
1212 };
1213 (f(static_cast<C*>(nullptr)), ...);
1214 if constexpr (has_index<C...>) {
1215 this->setIndices(this->getIndices());
1216 this->setOffsets(this->getOffsets());
1217 }
1218 }
1219
1220 template <typename DC, typename... B>
1221 auto bindDynamicColumn(framework::pack<B...>)
1222 {
1223 DC::boundIterators = std::make_tuple(getDynamicBinding<B>()...);
1224 }
1225
1226 // Sometimes dynamic columns are defined for tables in
1227 // the hope that it will be joined / extended with another one which provides
1228 // the full set of bindings. This is to avoid a compilation
1229 // error if constructor for the table or any other thing involving a missing
1230 // binding is preinstanciated.
1231 template <typename B>
1232 requires(can_bind<self_t, B>)
1233 decltype(auto) getDynamicBinding()
1234 {
1235 static_assert(std::same_as<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
1236 return &(static_cast<B*>(this)->mColumnIterator);
1237 // return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
1238 }
1239
1240 template <typename B>
1241 decltype(auto) getDynamicBinding()
1242 {
1243 return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
1244 }
1245};
1246
1248 static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
1249 static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
1250};
1251
1253template <typename T>
1255
1256template <typename T>
1257concept with_originals = requires {
1258 T::originals.size();
1259};
1260
1261template <typename T>
1262concept with_sources = requires {
1263 T::sources.size();
1264};
1265
1266template <typename T>
1267concept with_base_table = not_void<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>;
1268
1269template <size_t N1, std::array<TableRef, N1> os1, size_t N2, std::array<TableRef, N2> os2>
1270consteval bool is_compatible()
1271{
1272 return []<size_t... Is>(std::index_sequence<Is...>) {
1273 return ([]<size_t... Ks>(std::index_sequence<Ks...>) {
1274 constexpr auto h = os1[Is].desc_hash;
1275 using H = o2::aod::Hash<h>;
1276 return (((h == os2[Ks].desc_hash) || is_ng_index_equivalent_v<H, o2::aod::Hash<os2[Ks].desc_hash>>) || ...);
1277 }(std::make_index_sequence<N2>()) ||
1278 ...);
1279 }(std::make_index_sequence<N1>());
1280}
1281
1282template <with_originals T, with_originals B>
1284{
1285 return is_compatible<T::originals.size(), T::originals, B::originals.size(), B::originals>();
1286}
1287
1288template <typename T, typename B>
1289using is_binding_compatible = std::conditional_t<is_binding_compatible_v<T, typename B::binding_t>(), std::true_type, std::false_type>;
1290
1291template <typename L, typename D, typename O, typename Key, typename H, typename... Ts>
1292struct IndexTable;
1293
1294template <typename T>
1296
1297template <soa::is_table T>
1298static constexpr std::string getLabelForTable()
1299{
1300 return std::string{aod::label<std::decay_t<T>::originals[0]>()};
1301}
1302
1303template <soa::is_table T>
1305static constexpr std::string getLabelFromType()
1306{
1307 return getLabelForTable<T>();
1308}
1309
1310template <soa::is_iterator T>
1311static constexpr std::string getLabelFromType()
1312{
1313 return getLabelForTable<typename std::decay_t<T>::parent_t>();
1314}
1315
1316template <soa::is_index_table T>
1317static constexpr std::string getLabelFromType()
1318{
1319 return getLabelForTable<typename std::decay_t<T>::first_t>();
1320}
1321template <soa::with_base_table T>
1322static constexpr std::string getLabelFromType()
1323{
1324 return getLabelForTable<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>();
1325}
1326
1327template <typename... C>
1328static constexpr auto hasColumnForKey(framework::pack<C...>, std::string const& key)
1329{
1330 return ((C::inherited_t::mLabel == key) || ...);
1331}
1332
1333template <TableRef ref>
1334static constexpr std::pair<bool, std::string> hasKey(std::string const& key)
1335{
1336 return {hasColumnForKey(typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{}, key), aod::label<ref>()};
1337}
1338
1339template <typename... C>
1340static constexpr auto haveKey(framework::pack<C...>, std::string const& key)
1341{
1342 return std::vector{hasKey<C>(key)...};
1343}
1344
1345void notFoundColumn(const char* label, const char* key);
1346void missingOptionalPreslice(const char* label, const char* key);
1347
1348template <with_originals T, bool OPT = false>
1349static constexpr std::string getLabelFromTypeForKey(std::string const& key)
1350{
1351 if constexpr (T::originals.size() == 1) {
1352 auto locate = hasKey<T::originals[0]>(key);
1353 if (locate.first) {
1354 return locate.second;
1355 }
1356 } else {
1357 auto locate = [&]<size_t... Is>(std::index_sequence<Is...>) {
1358 return std::vector{hasKey<T::originals[Is]>(key)...};
1359 }(std::make_index_sequence<T::originals.size()>{});
1360 auto it = std::find_if(locate.begin(), locate.end(), [](auto const& x) { return x.first; });
1361 if (it != locate.end()) {
1362 return it->second;
1363 }
1364 }
1365 if constexpr (!OPT) {
1366 notFoundColumn(getLabelFromType<std::decay_t<T>>().data(), key.data());
1367 } else {
1368 return "[MISSING]";
1369 }
1371}
1372
1373template <typename B, typename... C>
1374consteval static bool hasIndexTo(framework::pack<C...>&&)
1375{
1376 return (o2::soa::is_binding_compatible_v<B, typename C::binding_t>() || ...);
1377}
1378
1379template <typename B, typename... C>
1380consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
1381{
1382 return ((C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()) || ...);
1383}
1384
1385template <typename B, typename Z>
1386consteval static bool relatedByIndex()
1387{
1388 return hasIndexTo<B>(typename Z::table_t::external_index_columns_t{});
1389}
1390
1391template <typename B, typename Z>
1392consteval static bool relatedBySortedIndex()
1393{
1394 return hasSortedIndexTo<B>(typename Z::table_t::external_index_columns_t{});
1395}
1396} // namespace o2::soa
1397
1398namespace o2::framework
1399{
1400
1402 const std::string binding;
1404
1405 bool isMissing() const;
1406 StringPair const& getBindingKey() const;
1407};
1408
1410 void updateSliceInfo(SliceInfoPtr&& si);
1411
1413 std::shared_ptr<arrow::Table> getSliceFor(int value, std::shared_ptr<arrow::Table> const& input, uint64_t& offset) const;
1414};
1415
1418
1420 gsl::span<const int64_t> getSliceFor(int value) const;
1421};
1422
1423template <typename T, typename Policy, bool OPT = false>
1424struct PresliceBase : public Policy {
1425 constexpr static bool optional = OPT;
1426 using target_t = T;
1427 using policy_t = Policy;
1428 const std::string binding;
1429
1431 : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
1432 {
1433 }
1434
1435 std::shared_ptr<arrow::Table> getSliceFor(int value, std::shared_ptr<arrow::Table> const& input, uint64_t& offset) const
1436 {
1437 if constexpr (OPT) {
1438 if (Policy::isMissing()) {
1439 return nullptr;
1440 }
1441 }
1442 return Policy::getSliceFor(value, input, offset);
1443 }
1444
1445 gsl::span<const int64_t> getSliceFor(int value) const
1446 {
1447 if constexpr (OPT) {
1448 if (Policy::isMissing()) {
1449 return {};
1450 }
1451 }
1452 return Policy::getSliceFor(value);
1453 }
1454};
1455
1456template <typename T>
1458template <typename T>
1460template <typename T>
1462template <typename T>
1464
1465template <typename T>
1466concept is_preslice = std::derived_from<T, PreslicePolicyBase>;
1467
1468} // namespace o2::framework
1469
1470namespace o2::soa
1471{
1472template <soa::is_table T>
1473class FilteredBase;
1474template <typename T>
1475class Filtered;
1476
1477template <typename T>
1478concept has_filtered_policy = not_void<typename T::policy_t> && std::same_as<typename T::policy_t, soa::FilteredIndexPolicy>;
1479
1480template <typename T>
1482
1483template <typename T>
1485
1486// FIXME: compatbility declaration to be removed
1487template <typename T>
1489
1490template <typename T>
1492
1493template <typename T>
1495
1497template <typename... Is>
1498static consteval auto extractBindings(framework::pack<Is...>)
1499{
1500 return framework::pack<typename Is::binding_t...>{};
1501}
1502
1504
1505template <typename T, typename C, typename Policy, bool OPT>
1506 requires std::same_as<Policy, framework::PreslicePolicySorted> && (o2::soa::is_binding_compatible_v<C, T>())
1507auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const& container, int value)
1508{
1509 if constexpr (OPT) {
1510 if (container.isMissing()) {
1511 missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
1512 }
1513 }
1514 uint64_t offset = 0;
1515 auto out = container.getSliceFor(value, table->asArrowTable(), offset);
1516 auto t = typename T::self_t({out}, offset);
1517 table->copyIndexBindings(t);
1518 t.bindInternalIndicesTo(table);
1519 return t;
1520}
1521
1522template <soa::is_filtered_table T>
1523auto doSliceByHelper(T const* table, gsl::span<const int64_t> const& selection)
1524{
1525 auto t = soa::Filtered<typename T::base_t>({table->asArrowTable()}, selection);
1526 table->copyIndexBindings(t);
1527 t.bindInternalIndicesTo(table);
1528 t.intersectWithSelection(table->getSelectedRows()); // intersect filters
1529 return t;
1530}
1531
1532template <soa::is_table T>
1533 requires(!soa::is_filtered_table<T>)
1534auto doSliceByHelper(T const* table, gsl::span<const int64_t> const& selection)
1535{
1536 auto t = soa::Filtered<T>({table->asArrowTable()}, selection);
1537 table->copyIndexBindings(t);
1538 t.bindInternalIndicesTo(table);
1539 return t;
1540}
1541
1542template <typename T, typename C, typename Policy, bool OPT>
1543 requires std::same_as<Policy, framework::PreslicePolicyGeneral> && (o2::soa::is_binding_compatible_v<C, T>())
1544auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const& container, int value)
1545{
1546 if constexpr (OPT) {
1547 if (container.isMissing()) {
1548 missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
1549 }
1550 }
1551 auto selection = container.getSliceFor(value);
1552 return doSliceByHelper(table, selection);
1553}
1554
1555SelectionVector sliceSelection(gsl::span<int64_t const> const& mSelectedRows, int64_t nrows, uint64_t offset);
1556
1557template <soa::is_filtered_table T>
1558auto prepareFilteredSlice(T const* table, std::shared_ptr<arrow::Table> slice, uint64_t offset)
1559{
1560 if (offset >= static_cast<uint64_t>(table->tableSize())) {
1561 Filtered<typename T::base_t> fresult{{{slice}}, SelectionVector{}, 0};
1562 table->copyIndexBindings(fresult);
1563 return fresult;
1564 }
1565 auto slicedSelection = sliceSelection(table->getSelectedRows(), slice->num_rows(), offset);
1566 Filtered<typename T::base_t> fresult{{{slice}}, std::move(slicedSelection), offset};
1567 table->copyIndexBindings(fresult);
1568 return fresult;
1569}
1570
1571template <soa::is_filtered_table T, typename C, bool OPT>
1572 requires(o2::soa::is_binding_compatible_v<C, T>())
1574{
1575 if constexpr (OPT) {
1576 if (container.isMissing()) {
1577 missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.second.c_str());
1578 }
1579 }
1580 uint64_t offset = 0;
1581 auto slice = container.getSliceFor(value, table->asArrowTable(), offset);
1582 return prepareFilteredSlice(table, slice, offset);
1583}
1584
1585template <typename T>
1587{
1588 auto localCache = cache.ptr->getCacheFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
1589 auto [offset, count] = localCache.getSliceFor(value);
1590 auto t = typename T::self_t({table->asArrowTable()->Slice(static_cast<uint64_t>(offset), count)}, static_cast<uint64_t>(offset));
1591 table->copyIndexBindings(t);
1592 return t;
1593}
1594
1595template <typename T>
1597{
1598 auto localCache = cache.ptr->getCacheFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
1599 auto [offset, count] = localCache.getSliceFor(value);
1600 auto slice = table->asArrowTable()->Slice(static_cast<uint64_t>(offset), count);
1601 return prepareFilteredSlice(table, slice, offset);
1602}
1603
1604template <typename T>
1606{
1607 auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
1608 if constexpr (soa::is_filtered_table<T>) {
1609 auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
1610 t.intersectWithSelection(table->getSelectedRows());
1611 table->copyIndexBindings(t);
1612 return t;
1613 } else {
1614 auto t = Filtered<T>({table->asArrowTable()}, localCache.getSliceFor(value));
1615 table->copyIndexBindings(t);
1616 return t;
1617 }
1618}
1619
1620template <with_originals T>
1622{
1623 return Filtered<T>({t.asArrowTable()}, selectionToVector(framework::expressions::createSelection(t.asArrowTable(), f)));
1624}
1625
1626arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, std::string_view label);
1627
1628template <typename D, typename O, typename IP, typename... C>
1629consteval auto base_iter(framework::pack<C...>&&) -> TableIterator<D, O, IP, C...>
1630{
1631}
1632
1633template <TableRef ref, typename... Ts>
1634 requires((sizeof...(Ts) > 0) && (soa::is_column<Ts> && ...))
1635consteval auto getColumns()
1636{
1637 return framework::pack<Ts...>{};
1638}
1639
1640template <TableRef ref, typename... Ts>
1641 requires((sizeof...(Ts) > 0) && !(soa::is_column<Ts> || ...) && (ref.origin_hash == "CONC"_h))
1642consteval auto getColumns()
1643{
1644 return framework::full_intersected_pack_t<typename Ts::columns_t...>{};
1645}
1646
1647template <TableRef ref, typename... Ts>
1648 requires((sizeof...(Ts) > 0) && !(soa::is_column<Ts> || ...) && (ref.origin_hash != "CONC"_h))
1649consteval auto getColumns()
1650{
1651 return framework::concatenated_pack_unique_t<typename Ts::columns_t...>{};
1652}
1653
1654template <TableRef ref, typename... Ts>
1655 requires(sizeof...(Ts) == 0 && soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>>)
1656consteval auto getColumns()
1657{
1658 return typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{};
1659}
1660
1661template <TableRef ref, typename... Ts>
1662 requires((sizeof...(Ts) == 0) || (o2::soa::is_column<Ts> && ...))
1663consteval auto computeOriginals()
1664{
1665 return std::array<TableRef, 1>{ref};
1666}
1667
1668template <TableRef ref, typename... Ts>
1669 requires((sizeof...(Ts) > 0) && (!o2::soa::is_column<Ts> || ...))
1670consteval auto computeOriginals()
1671{
1672 return o2::soa::mergeOriginals<Ts...>();
1673}
1674
1677template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... Ts>
1679{
1680 public:
1681 static constexpr const auto ref = TableRef{L::hash, D::hash, O::hash, o2::aod::version(D::str)};
1682 using self_t = Table<L, D, O, Ts...>;
1684
1685 static constexpr const auto originals = computeOriginals<ref, Ts...>();
1686
1687 template <size_t N, std::array<TableRef, N> bindings>
1688 requires(ref.origin_hash == "CONC"_h)
1689 static consteval auto isIndexTargetOf()
1690 {
1691 return false;
1692 }
1693
1694 template <size_t N, std::array<TableRef, N> bindings>
1695 requires(ref.origin_hash == "JOIN"_h)
1696 static consteval auto isIndexTargetOf()
1697 {
1698 return std::find_if(self_t::originals.begin(), self_t::originals.end(),
1699 [](TableRef const& r) {
1700 return std::find(bindings.begin(), bindings.end(), r) != bindings.end();
1701 }) != self_t::originals.end();
1702 }
1703
1704 template <size_t N, std::array<TableRef, N> bindings>
1705 requires(!(ref.origin_hash == "CONC"_h || ref.origin_hash == "JOIN"_h))
1706 static consteval auto isIndexTargetOf()
1707 {
1708 return std::find(bindings.begin(), bindings.end(), self_t::ref) != bindings.end();
1709 }
1710
1711 template <TableRef r>
1712 static consteval bool hasOriginal()
1713 {
1714 return std::find_if(originals.begin(), originals.end(), [](TableRef const& o) { return o.desc_hash == r.desc_hash; }) != originals.end();
1715 }
1716
1717 using columns_t = decltype(getColumns<ref, Ts...>());
1718
1721
1724 template <typename IP>
1725 using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
1726
1727 template <typename IP, typename Parent, typename... T>
1729 using columns_t = typename Parent::columns_t;
1730 using external_index_columns_t = typename Parent::external_index_columns_t;
1732 // static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
1733 static constexpr auto originals = Parent::originals;
1734 using policy_t = IP;
1735 using parent_t = Parent;
1736
1738
1739 TableIteratorBase(arrow::ChunkedArray* columnData[framework::pack_size(columns_t{})], IP&& policy)
1740 : base_iterator<IP>(columnData, std::forward<decltype(policy)>(policy))
1741 {
1742 }
1743
1744 template <typename P, typename... Os>
1746 requires(P::ref.desc_hash == Parent::ref.desc_hash)
1747 {
1748 static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<IP>>(other);
1749 return *this;
1750 }
1751
1752 template <typename P>
1754 {
1755 static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<IP>>(other);
1756 return *this;
1757 }
1758
1759 template <typename P>
1761 requires std::same_as<IP, DefaultIndexPolicy>
1762 {
1763 static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<FilteredIndexPolicy>>(other);
1764 return *this;
1765 }
1766
1767 template <typename P, typename O1, typename... Os>
1769 requires(P::ref.desc_hash == Parent::ref.desc_hash)
1770 {
1771 *this = other;
1772 }
1773
1774 template <typename P, typename O1, typename... Os>
1776 requires(P::ref.desc_hash == Parent::ref.desc_hash)
1777 {
1778 *this = other;
1779 }
1780
1781 template <typename P>
1786
1787 template <typename P>
1789 {
1790 *this = other;
1791 }
1792
1793 template <typename P>
1795 requires std::same_as<IP, DefaultIndexPolicy>
1796 {
1797 *this = other;
1798 }
1799
1801 {
1802 this->mRowIndex = other.index;
1803 return *this;
1804 }
1805 template <typename P>
1807 {
1808 this->mRowIndex = other.mRowIndex;
1809 }
1810
1811 template <typename P, typename... Os>
1813 requires std::same_as<typename P::table_t, typename Parent::table_t>
1814 {
1815 this->mRowIndex = other.mRowIndex;
1816 }
1817
1818 template <typename TI>
1819 auto getId() const
1820 {
1821 using decayed = std::decay_t<TI>;
1822 if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
1823 constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
1825 } else if constexpr (std::same_as<decayed, Parent>) { // self index
1826 return this->globalIndex();
1827 } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
1828 return this->globalIndex();
1829 } else {
1830 return static_cast<int32_t>(-1);
1831 }
1832 }
1833
1834 template <typename CD, typename... CDArgs>
1835 auto getDynamicColumn() const
1836 {
1837 using decayed = std::decay_t<CD>;
1838 static_assert(is_dynamic_t<decayed>(), "Requested column is not a dynamic column");
1839 return static_cast<decayed>(*this).template getDynamicValue<CDArgs...>();
1840 }
1841
1842 template <typename B, typename CC>
1843 auto getValue() const
1844 {
1845 using COL = std::decay_t<CC>;
1846 static_assert(is_dynamic_t<COL>() || soa::is_persistent_column<COL>, "Should be persistent or dynamic column with no argument that has a return type convertable to float");
1847 return static_cast<B>(static_cast<COL>(*this).get());
1848 }
1849
1850 template <typename B, typename... CCs>
1851 std::array<B, sizeof...(CCs)> getValues() const
1852 {
1853 static_assert(std::same_as<B, float> || std::same_as<B, double>, "The common return type should be float or double");
1854 return {getValue<B, CCs>()...};
1855 }
1856
1857 using IP::size;
1858
1859 using base_iterator<IP>::operator++;
1860
1862 TableIteratorBase operator+(int64_t inc) const
1863 {
1864 TableIteratorBase copy = *this;
1865 copy.moveByIndex(inc);
1866 return copy;
1867 }
1868
1869 TableIteratorBase operator-(int64_t dec) const
1870 {
1871 return operator+(-dec);
1872 }
1873
1875 {
1876 return *this;
1877 }
1878 };
1879
1880 template <typename IP, typename Parent, typename... T>
1882
1883 template <typename IP, typename Parent>
1884 static consteval auto full_iter()
1885 {
1886 if constexpr (sizeof...(Ts) == 0) {
1888 } else {
1889 if constexpr ((o2::soa::is_column<Ts> && ...)) {
1891 } else {
1892 return iterator_template<IP, Parent, Ts...>{};
1893 }
1894 }
1895 }
1896
1897 template <typename IP, typename Parent>
1898 using iterator_template_o = decltype(full_iter<IP, Parent>());
1899
1902
1906
1907 static constexpr auto hashes()
1908 {
1909 return []<typename... C>(framework::pack<C...>) { return std::set{{o2::framework::TypeIdHelpers::uniqueId<C>()...}}; }(columns_t{});
1910 }
1911
1912 Table(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
1913 : mTable(table),
1914 mEnd{table->num_rows()},
1915 mOffset(offset)
1916 {
1917 if (mTable->num_rows() == 0) {
1918 for (size_t ci = 0; ci < framework::pack_size(columns_t{}); ++ci) {
1919 mColumnChunks[ci] = nullptr;
1920 }
1921 mBegin = mEnd;
1922 } else {
1923 auto lookups = [this]<typename... C>(framework::pack<C...>) -> std::array<arrow::ChunkedArray*, framework::pack_size(columns_t{})> { return {lookupColumn<C>()...}; }(columns_t{});
1924 for (size_t ci = 0; ci < framework::pack_size(columns_t{}); ++ci) {
1925 mColumnChunks[ci] = lookups[ci];
1926 }
1927 mBegin = unfiltered_iterator{mColumnChunks, {table->num_rows(), offset}};
1928 mBegin.bindInternalIndices(this);
1929 }
1930 }
1931
1932 Table(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
1933 requires(ref.origin_hash != "CONC"_h)
1934 : Table(ArrowHelpers::joinTables(std::move(tables)), offset)
1935 {
1936 }
1937
1938 Table(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
1939 requires(ref.origin_hash == "CONC"_h)
1940 : Table(ArrowHelpers::concatTables(std::move(tables)), offset)
1941 {
1942 }
1943
1944 template <typename Key>
1945 inline arrow::ChunkedArray* getIndexToKey()
1946 {
1947 constexpr auto map = []<typename... Cs>(framework::pack<Cs...>) {
1948 return std::array<bool, sizeof...(Cs)>{[]() {
1949 if constexpr (requires { Cs::index_targets.size(); }) {
1950 return Key::template isIndexTargetOf<Cs::index_targets.size(), Cs::index_targets>();
1951 } else {
1952 return false;
1953 }
1954 }()...};
1956 constexpr auto pos = std::find(map.begin(), map.end(), true);
1957 if constexpr (pos != map.end()) {
1958 return mColumnChunks[std::distance(map.begin(), pos)];
1959 } else {
1960 static_assert(framework::always_static_assert_v<Key>, "This table does not have an index to given Key");
1961 }
1962 }
1963
1965 {
1966 return mBegin;
1967 }
1968
1969 auto const& cached_begin() const
1970 {
1971 return mBegin;
1972 }
1973
1975 {
1976 return unfiltered_iterator(mBegin);
1977 }
1978
1980 {
1981 return RowViewSentinel{mEnd};
1982 }
1983
1984 filtered_iterator filtered_begin(gsl::span<int64_t const> selection)
1985 {
1986 // Note that the FilteredIndexPolicy will never outlive the selection which
1987 // is held by the table, so we are safe passing the bare pointer. If it does it
1988 // means that the iterator on a table is outliving the table itself, which is
1989 // a bad idea.
1990 return filtered_iterator(mColumnChunks, {selection, mTable->num_rows(), mOffset});
1991 }
1992
1993 iterator iteratorAt(uint64_t i) const
1994 {
1995 return rawIteratorAt(i);
1996 }
1997
1999 {
2000 auto it = mBegin;
2001 it.setCursor(i);
2002 return it;
2003 }
2004
2006 {
2007 return unfiltered_const_iterator(mBegin);
2008 }
2009
2010 [[nodiscard]] RowViewSentinel end() const
2011 {
2012 return RowViewSentinel{mEnd};
2013 }
2014
2016 [[nodiscard]] std::shared_ptr<arrow::Table> asArrowTable() const
2017 {
2018 return mTable;
2019 }
2021 auto offset() const
2022 {
2023 return mOffset;
2024 }
2026 [[nodiscard]] int64_t size() const
2027 {
2028 return mTable->num_rows();
2029 }
2030
2031 [[nodiscard]] int64_t tableSize() const
2032 {
2033 return size();
2034 }
2035
2038 template <typename... TA>
2039 void bindExternalIndices(TA*... current)
2040 {
2041 mBegin.bindExternalIndices(current...);
2042 }
2043
2044 template <typename I>
2046 {
2047 mBegin.bindInternalIndices(ptr);
2048 }
2049
2054
2055 template <typename... Cs>
2057 {
2058 (static_cast<Cs>(mBegin).setCurrentRaw(binding), ...);
2059 }
2060
2061 void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
2062 {
2063 mBegin.bindExternalIndicesRaw(std::forward<std::vector<o2::soa::Binding>>(ptrs));
2064 }
2065
2066 template <typename T, typename... Cs>
2068 {
2069 dest.bindExternalIndicesRaw(mBegin.getIndexBindings());
2070 }
2071
2072 template <typename T>
2073 void copyIndexBindings(T& dest) const
2074 {
2076 }
2077
2079 {
2080 auto t = o2::soa::select(*this, f);
2082 return t;
2083 }
2084
2086 {
2087 return doSliceByCached(this, node, value, cache);
2088 }
2089
2091 {
2092 return doSliceByCachedUnsorted(this, node, value, cache);
2093 }
2094
2095 template <typename T1, typename Policy, bool OPT>
2097 {
2098 return doSliceBy(this, container, value);
2099 }
2100
2101 auto rawSlice(uint64_t start, uint64_t end) const
2102 {
2103 return self_t{mTable->Slice(start, end - start + 1), start};
2104 }
2105
2106 auto emptySlice() const
2107 {
2108 return self_t{mTable->Slice(0, 0), 0};
2109 }
2110
2111 private:
2112 template <typename T>
2113 arrow::ChunkedArray* lookupColumn()
2114 {
2115 if constexpr (soa::is_persistent_column<T>) {
2116 auto label = T::columnLabel();
2117 return getIndexFromLabel(mTable.get(), label);
2118 } else {
2119 return nullptr;
2120 }
2121 }
2122 std::shared_ptr<arrow::Table> mTable = nullptr;
2123 uint64_t mOffset = 0;
2124 // Cached pointers to the ChunkedArray associated to a column
2125 arrow::ChunkedArray* mColumnChunks[framework::pack_size(columns_t{})];
2126 RowViewSentinel mEnd;
2127 iterator mBegin;
2128};
2129
2130template <uint32_t D, soa::is_column... C>
2132
2133void getterNotFound(const char* targetColumnLabel);
2134void emptyColumnLabel();
2135
2136namespace row_helpers
2137{
2138template <soa::is_persistent_column... Cs>
2139std::array<arrow::ChunkedArray*, sizeof...(Cs)> getArrowColumns(arrow::Table* table, framework::pack<Cs...>)
2140{
2141 return std::array<arrow::ChunkedArray*, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())...};
2142}
2143
2144template <soa::is_persistent_column... Cs>
2145std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)> getChunks(arrow::Table* table, framework::pack<Cs...>, uint64_t ci)
2146{
2147 return std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())->chunk(ci)...};
2148}
2149
2150template <typename T, soa::is_persistent_column C>
2151typename C::type getSingleRowData(arrow::Table* table, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
2152{
2153 if (ci == std::numeric_limits<uint64_t>::max() || ai == std::numeric_limits<uint64_t>::max()) {
2154 auto colIterator = static_cast<C>(rowIterator).getIterator();
2155 ci = colIterator.mCurrentChunk;
2156 ai = *(colIterator.mCurrentPos) - colIterator.mFirstIndex;
2157 }
2158 return std::static_pointer_cast<o2::soa::arrow_array_for_t<typename C::type>>(o2::soa::getIndexFromLabel(table, C::columnLabel())->chunk(ci))->raw_values()[ai];
2159}
2160
2161template <typename T, soa::is_dynamic_column C>
2162typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
2163{
2164 if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
2165 rowIterator.setCursor(globalIndex);
2166 }
2167 return rowIterator.template getDynamicColumn<C>();
2168}
2169
2170template <typename T, soa::is_index_column C>
2171typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
2172{
2173 if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
2174 rowIterator.setCursor(globalIndex);
2175 }
2176 return rowIterator.template getId<C>();
2177}
2178
2179template <typename T, typename... Cs>
2180std::tuple<typename Cs::type...> getRowData(arrow::Table* table, T rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
2181{
2182 return std::make_tuple(getSingleRowData<T, Cs>(table, rowIterator, ci, ai, globalIndex)...);
2183}
2184
2185namespace
2186{
2187template <typename R, typename T, typename C>
2188R getColumnValue(const T& rowIterator)
2189{
2190 return static_cast<R>(static_cast<C>(rowIterator).get());
2191}
2192
2193template <typename R, typename T>
2194using ColumnGetterFunction = R (*)(const T&);
2195
2196template <typename T, typename R>
2198 // lambda is callable without additional free args
2199 framework::pack_size(typename T::bindings_t{}) == framework::pack_size(typename T::callable_t::args{}) &&
2200 requires(T t) {
2201 { t.get() } -> std::convertible_to<R>;
2202 };
2203
2204template <typename T, typename R>
2205concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
2206 { t.get() } -> std::convertible_to<R>;
2207};
2208
2209template <typename R, typename T, persistent_with_common_getter<R> C>
2210ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& targetColumnLabel)
2211{
2212 return targetColumnLabel == C::columnLabel() ? &getColumnValue<R, T, C> : nullptr;
2213}
2214
2215template <typename R, typename T, dynamic_with_common_getter<R> C>
2216ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& targetColumnLabel)
2217{
2218 std::string_view columnLabel(C::columnLabel());
2219
2220 // allows user to use consistent formatting (with prefix) of all column labels
2221 // by default there isn't 'f' prefix for dynamic column labels
2222 if (targetColumnLabel.starts_with("f") && targetColumnLabel.substr(1) == columnLabel) {
2223 return &getColumnValue<R, T, C>;
2224 }
2225
2226 // check also exact match if user is aware of prefix missing
2227 if (targetColumnLabel == columnLabel) {
2228 return &getColumnValue<R, T, C>;
2229 }
2230
2231 return nullptr;
2232}
2233
2234template <typename R, typename T, typename... Cs>
2235ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& targetColumnLabel)
2236{
2237 ColumnGetterFunction<R, T> func;
2238
2239 (void)((func = createGetterPtr<R, T, Cs>(targetColumnLabel), func) || ...);
2240
2241 if (!func) {
2242 getterNotFound(targetColumnLabel.data());
2243 }
2244
2245 return func;
2246}
2247
2248template <typename T, typename R>
2249using with_common_getter_t = typename std::conditional<persistent_with_common_getter<T, R> || dynamic_with_common_getter<T, R>, std::true_type, std::false_type>::type;
2250} // namespace
2251
2252template <typename R, typename T>
2253ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& targetColumnLabel)
2254{
2255 using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns_t>;
2256
2257 if (targetColumnLabel.size() == 0) {
2259 }
2260
2261 return getColumnGetterByLabel<R, typename T::iterator>(TypesWithCommonGetter{}, targetColumnLabel);
2262}
2263} // namespace row_helpers
2264} // namespace o2::soa
2265
2266namespace o2::aod
2267{
2269O2ORIGIN("AOD1");
2270O2ORIGIN("AOD2");
2273O2ORIGIN("JOIN");
2274O2HASH("JOIN/0");
2275O2ORIGIN("CONC");
2276O2HASH("CONC/0");
2277O2ORIGIN("TEST");
2278O2HASH("TEST/0");
2279} // namespace o2::aod
2280
2281#define DECLARE_EQUIVALENT_FOR_INDEX(_Base_, _Equiv_) \
2282 template <> \
2283 struct EquivalentIndexNG<o2::aod::Hash<_Base_::ref.desc_hash>, o2::aod::Hash<_Equiv_::ref.desc_hash>> { \
2284 constexpr static bool value = true; \
2285 }
2286
2287#define DECLARE_EQUIVALENT_FOR_INDEX_NG(_Base_, _Equiv_) \
2288 template <> \
2289 struct EquivalentIndexNG<o2::aod::Hash<_Base_ ""_h>, o2::aod::Hash<_Equiv_ ""_h>> { \
2290 constexpr static bool value = true; \
2291 }
2292
2293#define DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) \
2294 struct _Name_ : o2::soa::Column<_Type_, _Name_> { \
2295 static constexpr const char* mLabel = _Label_; \
2296 static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
2297 using base = o2::soa::Column<_Type_, _Name_>; \
2298 using type = _Type_; \
2299 using column_t = _Name_; \
2300 _Name_(arrow::ChunkedArray const* column) \
2301 : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column)) \
2302 { \
2303 } \
2304 \
2305 _Name_() = default; \
2306 _Name_(_Name_ const& other) = default; \
2307 _Name_& operator=(_Name_ const& other) = default; \
2308 \
2309 decltype(auto) _Getter_() const \
2310 { \
2311 return *mColumnIterator; \
2312 } \
2313 \
2314 decltype(auto) get() const \
2315 { \
2316 return _Getter_(); \
2317 } \
2318 }; \
2319 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
2320 o2::framework::expressions::selectArrowType<_Type_>() }
2321
2322#define DECLARE_SOA_COLUMN(_Name_, _Getter_, _Type_) \
2323 DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_)
2324
2327#define MAKEINT(_Size_) uint##_Size_##_t
2328
2329#define DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, _Label_) \
2330 struct _Name_ : o2::soa::Column<MAKEINT(_Size_), _Name_> { \
2331 static constexpr const char* mLabel = _Label_; \
2332 static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
2333 using base = o2::soa::Column<MAKEINT(_Size_), _Name_>; \
2334 using type = MAKEINT(_Size_); \
2335 _Name_(arrow::ChunkedArray const* column) \
2336 : o2::soa::Column<type, _Name_>(o2::soa::ColumnIterator<type>(column)) \
2337 { \
2338 } \
2339 \
2340 _Name_() = default; \
2341 _Name_(_Name_ const& other) = default; \
2342 _Name_& operator=(_Name_ const& other) = default; \
2343 \
2344 decltype(auto) _Getter_##_raw() const \
2345 { \
2346 return *mColumnIterator; \
2347 } \
2348 \
2349 bool _Getter_##_bit(int bit) const \
2350 { \
2351 return (*mColumnIterator & (static_cast<type>(1) << bit)) >> bit; \
2352 } \
2353 }; \
2354 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
2355 o2::framework::expressions::selectArrowType<MAKEINT(_Size_)>() }
2356
2357#define DECLARE_SOA_BITMAP_COLUMN(_Name_, _Getter_, _Size_) \
2358 DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, "f" #_Name_)
2359
2362#define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_) \
2363 struct _Name_ : o2::soa::Column<_Type_, _Name_> { \
2364 static constexpr const char* mLabel = _Label_; \
2365 using base = o2::soa::Column<_Type_, _Name_>; \
2366 using type = _Type_; \
2367 using column_t = _Name_; \
2368 using spawnable_t = std::true_type; \
2369 _Name_(arrow::ChunkedArray const* column) \
2370 : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column)) \
2371 { \
2372 } \
2373 \
2374 _Name_() = default; \
2375 _Name_(_Name_ const& other) = default; \
2376 _Name_& operator=(_Name_ const& other) = default; \
2377 \
2378 decltype(auto) _Getter_() const \
2379 { \
2380 return *mColumnIterator; \
2381 } \
2382 \
2383 decltype(auto) get() const \
2384 { \
2385 return _Getter_(); \
2386 } \
2387 \
2388 static o2::framework::expressions::Projector Projector() \
2389 { \
2390 return _Expression_; \
2391 } \
2392 }; \
2393 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
2394 o2::framework::expressions::selectArrowType<_Type_>() }
2395
2396#define DECLARE_SOA_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Expression_) \
2397 DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_, _Expression_);
2398
2401#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_) \
2402 struct _Name_ : o2::soa::Column<_Type_, _Name_> { \
2403 static constexpr const char* mLabel = _Label_; \
2404 static constexpr const int32_t mHash = _Label_ ""_h; \
2405 using base = o2::soa::Column<_Type_, _Name_>; \
2406 using type = _Type_; \
2407 using column_t = _Name_; \
2408 using spawnable_t = std::true_type; \
2409 _Name_(arrow::ChunkedArray const* column) \
2410 : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column)) \
2411 { \
2412 } \
2413 \
2414 _Name_() = default; \
2415 _Name_(_Name_ const& other) = default; \
2416 _Name_& operator=(_Name_ const& other) = default; \
2417 \
2418 decltype(auto) _Getter_() const \
2419 { \
2420 return *mColumnIterator; \
2421 } \
2422 \
2423 decltype(auto) get() const \
2424 { \
2425 return _Getter_(); \
2426 } \
2427 }; \
2428 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
2429 o2::framework::expressions::selectArrowType<_Type_>() }
2430
2449
2451
2452template <o2::soa::is_table T>
2453consteval auto getIndexTargets()
2454{
2455 return T::originals;
2456}
2457
2458#define DECLARE_SOA_SLICE_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_) \
2459 struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> { \
2460 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2461 static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _"); \
2462 static constexpr const char* mLabel = "fIndexSlice" _Label_ _Suffix_; \
2463 using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>; \
2464 using type = _Type_[2]; \
2465 using column_t = _Name_##IdSlice; \
2466 using binding_t = _Table_; \
2467 static constexpr auto index_targets = getIndexTargets<_Table_>(); \
2468 _Name_##IdSlice(arrow::ChunkedArray const* column) \
2469 : o2::soa::Column<_Type_[2], _Name_##IdSlice>(o2::soa::ColumnIterator<type>(column)) \
2470 { \
2471 } \
2472 \
2473 _Name_##IdSlice() = default; \
2474 _Name_##IdSlice(_Name_##IdSlice const& other) = default; \
2475 _Name_##IdSlice& operator=(_Name_##IdSlice const& other) = default; \
2476 std::array<_Type_, 2> inline getIds() const \
2477 { \
2478 return _Getter_##Ids(); \
2479 } \
2480 \
2481 bool has_##_Getter_() const \
2482 { \
2483 auto a = *mColumnIterator; \
2484 return a[0] >= 0 && a[1] >= 0; \
2485 } \
2486 \
2487 std::array<_Type_, 2> _Getter_##Ids() const \
2488 { \
2489 auto a = *mColumnIterator; \
2490 return std::array{a[0], a[1]}; \
2491 } \
2492 \
2493 template <typename T> \
2494 auto _Getter_##_as() const \
2495 { \
2496 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2497 o2::soa::notBoundTable(#_Table_); \
2498 } \
2499 auto t = mBinding.get<T>(); \
2500 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2501 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2502 } \
2503 if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) { \
2504 return t->emptySlice(); \
2505 } \
2506 auto a = *mColumnIterator; \
2507 auto r = t->rawSlice(a[0], a[1]); \
2508 t->copyIndexBindings(r); \
2509 r.bindInternalIndicesTo(t); \
2510 return r; \
2511 } \
2512 \
2513 auto _Getter_() const \
2514 { \
2515 return _Getter_##_as<binding_t>(); \
2516 } \
2517 \
2518 template <typename T> \
2519 bool setCurrent(T const* current) \
2520 { \
2521 if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) { \
2522 assert(current != nullptr); \
2523 this->mBinding.bind(current); \
2524 return true; \
2525 } \
2526 return false; \
2527 } \
2528 \
2529 bool setCurrentRaw(o2::soa::Binding current) \
2530 { \
2531 this->mBinding = current; \
2532 return true; \
2533 } \
2534 binding_t const* getCurrent() const { return mBinding.get<binding_t>(); } \
2535 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2536 o2::soa::Binding mBinding; \
2537 };
2538
2539#define DECLARE_SOA_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_SLICE_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
2540#define DECLARE_SOA_SLICE_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, _Name_##s, "")
2541#define DECLARE_SOA_SLICE_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_SLICE_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
2542
2544#define DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_) \
2545 struct _Name_##Ids : o2::soa::Column<std::vector<_Type_>, _Name_##Ids> { \
2546 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2547 static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _"); \
2548 static constexpr const char* mLabel = "fIndexArray" _Label_ _Suffix_; \
2549 using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>; \
2550 using type = std::vector<_Type_>; \
2551 using column_t = _Name_##Ids; \
2552 using binding_t = _Table_; \
2553 static constexpr auto index_targets = getIndexTargets<_Table_>(); \
2554 _Name_##Ids(arrow::ChunkedArray const* column) \
2555 : o2::soa::Column<std::vector<_Type_>, _Name_##Ids>(o2::soa::ColumnIterator<type>(column)) \
2556 { \
2557 } \
2558 \
2559 _Name_##Ids() = default; \
2560 _Name_##Ids(_Name_##Ids const& other) = default; \
2561 _Name_##Ids& operator=(_Name_##Ids const& other) = default; \
2562 \
2563 gsl::span<const _Type_> inline getIds() const \
2564 { \
2565 return _Getter_##Ids(); \
2566 } \
2567 \
2568 gsl::span<const _Type_> _Getter_##Ids() const \
2569 { \
2570 return *mColumnIterator; \
2571 } \
2572 \
2573 bool has_##_Getter_() const \
2574 { \
2575 return !(*mColumnIterator).empty(); \
2576 } \
2577 \
2578 template <typename T> \
2579 auto _Getter_##_as() const \
2580 { \
2581 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2582 o2::soa::notBoundTable(#_Table_); \
2583 } \
2584 auto t = mBinding.get<T>(); \
2585 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2586 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2587 } \
2588 return getIterators<T>(); \
2589 } \
2590 \
2591 template <typename T> \
2592 auto filtered_##_Getter_##_as() const \
2593 { \
2594 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2595 o2::soa::notBoundTable(#_Table_); \
2596 } \
2597 auto t = mBinding.get<T>(); \
2598 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2599 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2600 } \
2601 return getFilteredIterators<T>(); \
2602 } \
2603 \
2604 template <typename T> \
2605 auto getIterators() const \
2606 { \
2607 auto result = std::vector<typename T::unfiltered_iterator>(); \
2608 for (auto& i : *mColumnIterator) { \
2609 result.push_back(mBinding.get<T>()->rawIteratorAt(i)); \
2610 } \
2611 return result; \
2612 } \
2613 \
2614 template <typename T> \
2615 std::vector<typename T::iterator> getFilteredIterators() const \
2616 { \
2617 if constexpr (o2::soa::is_filtered_table<T>) { \
2618 auto result = std::vector<typename T::iterator>(); \
2619 for (auto const& i : *mColumnIterator) { \
2620 auto pos = mBinding.get<T>()->isInSelectedRows(i); \
2621 if (pos > 0) { \
2622 result.emplace_back(mBinding.get<T>()->iteratorAt(pos)); \
2623 } \
2624 } \
2625 return result; \
2626 } else { \
2627 static_assert(o2::framework::always_static_assert_v<T>, "T is not a Filtered type"); \
2628 } \
2629 return {}; \
2630 } \
2631 \
2632 auto _Getter_() const \
2633 { \
2634 return _Getter_##_as<binding_t>(); \
2635 } \
2636 \
2637 template <typename T> \
2638 auto _Getter_##_first_as() const \
2639 { \
2640 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2641 o2::soa::notBoundTable(#_Table_); \
2642 } \
2643 auto t = mBinding.get<T>(); \
2644 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2645 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2646 } \
2647 return t->rawIteratorAt((*mColumnIterator)[0]); \
2648 } \
2649 \
2650 template <typename T> \
2651 auto _Getter_##_last_as() const \
2652 { \
2653 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2654 o2::soa::notBoundTable(#_Table_); \
2655 } \
2656 auto t = mBinding.get<T>(); \
2657 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2658 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2659 } \
2660 return t->rawIteratorAt((*mColumnIterator).back()); \
2661 } \
2662 \
2663 auto _Getter_first() const \
2664 { \
2665 return _Getter_##_first_as<binding_t>(); \
2666 } \
2667 \
2668 auto _Getter_last() const \
2669 { \
2670 return _Getter_##_last_as<binding_t>(); \
2671 } \
2672 \
2673 template <typename T> \
2674 bool setCurrent(T const* current) \
2675 { \
2676 if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) { \
2677 assert(current != nullptr); \
2678 this->mBinding.bind(current); \
2679 return true; \
2680 } \
2681 return false; \
2682 } \
2683 \
2684 bool setCurrentRaw(o2::soa::Binding current) \
2685 { \
2686 this->mBinding = current; \
2687 return true; \
2688 } \
2689 binding_t const* getCurrent() const { return mBinding.get<binding_t>(); } \
2690 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2691 o2::soa::Binding mBinding; \
2692 };
2693
2694#define DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
2695#define DECLARE_SOA_ARRAY_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, _Name_##s, "")
2696#define DECLARE_SOA_ARRAY_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
2697
2699#define DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_) \
2700 struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> { \
2701 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2702 static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _"); \
2703 static constexpr const char* mLabel = "fIndex" _Label_ _Suffix_; \
2704 using base = o2::soa::Column<_Type_, _Name_##Id>; \
2705 using type = _Type_; \
2706 using column_t = _Name_##Id; \
2707 using binding_t = _Table_; \
2708 static constexpr auto index_targets = getIndexTargets<_Table_>(); \
2709 _Name_##Id(arrow::ChunkedArray const* column) \
2710 : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column)) \
2711 { \
2712 } \
2713 \
2714 _Name_##Id() = default; \
2715 _Name_##Id(_Name_##Id const& other) = default; \
2716 _Name_##Id& operator=(_Name_##Id const& other) = default; \
2717 type inline getId() const \
2718 { \
2719 return _Getter_##Id(); \
2720 } \
2721 \
2722 type _Getter_##Id() const \
2723 { \
2724 return *mColumnIterator; \
2725 } \
2726 \
2727 bool has_##_Getter_() const \
2728 { \
2729 return *mColumnIterator >= 0; \
2730 } \
2731 \
2732 template <typename T> \
2733 auto _Getter_##_as() const \
2734 { \
2735 if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) { \
2736 o2::soa::notBoundTable(#_Table_); \
2737 } \
2738 if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) { \
2739 o2::soa::accessingInvalidIndexFor(#_Getter_); \
2740 } \
2741 auto t = mBinding.get<T>(); \
2742 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2743 o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_); \
2744 } \
2745 return t->rawIteratorAt(*mColumnIterator); \
2746 } \
2747 \
2748 auto _Getter_() const \
2749 { \
2750 return _Getter_##_as<binding_t>(); \
2751 } \
2752 \
2753 template <typename T> \
2754 bool setCurrent(T* current) \
2755 { \
2756 if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) { \
2757 assert(current != nullptr); \
2758 this->mBinding.bind(current); \
2759 return true; \
2760 } \
2761 return false; \
2762 } \
2763 \
2764 bool setCurrentRaw(o2::soa::Binding current) \
2765 { \
2766 this->mBinding = current; \
2767 return true; \
2768 } \
2769 binding_t const* getCurrent() const { return mBinding.get<binding_t>(); } \
2770 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2771 o2::soa::Binding mBinding; \
2772 }; \
2773 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" #_Table_ _Suffix_, o2::framework::TypeIdHelpers::uniqueId<_Name_##Id>(), \
2774 o2::framework::expressions::selectArrowType<_Type_>() }
2775
2776#define DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
2777#define DECLARE_SOA_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, _Name_##s, "")
2778#define DECLARE_SOA_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
2779
2781#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_) \
2782 struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> { \
2783 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2784 static constexpr const char* mLabel = "fIndex" _Label_; \
2785 using base = o2::soa::Column<_Type_, _Name_##Id>; \
2786 using type = _Type_; \
2787 using column_t = _Name_##Id; \
2788 using self_index_t = std::true_type; \
2789 using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>; \
2790 _Name_##Id(arrow::ChunkedArray const* column) \
2791 : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column)) \
2792 { \
2793 } \
2794 \
2795 _Name_##Id() = default; \
2796 _Name_##Id(_Name_##Id const& other) = default; \
2797 _Name_##Id& operator=(_Name_##Id const& other) = default; \
2798 type inline getId() const \
2799 { \
2800 return _Getter_##Id(); \
2801 } \
2802 \
2803 type _Getter_##Id() const \
2804 { \
2805 return *mColumnIterator; \
2806 } \
2807 \
2808 bool has_##_Getter_() const \
2809 { \
2810 return *mColumnIterator >= 0; \
2811 } \
2812 \
2813 template <typename T> \
2814 auto _Getter_##_as() const \
2815 { \
2816 if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) { \
2817 o2::soa::accessingInvalidIndexFor(#_Getter_); \
2818 } \
2819 auto t = mBinding.get<T>(); \
2820 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2821 o2::soa::dereferenceWithWrongType(#_Getter_, "self"); \
2822 } \
2823 return t->rawIteratorAt(*mColumnIterator); \
2824 } \
2825 \
2826 bool setCurrentRaw(o2::soa::Binding current) \
2827 { \
2828 this->mBinding = current; \
2829 return true; \
2830 } \
2831 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2832 o2::soa::Binding mBinding; \
2833 }; \
2834 [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_##Id>(), \
2835 o2::framework::expressions::selectArrowType<_Type_>() }
2836
2837#define DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
2838#define DECLARE_SOA_SELF_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, #_Name_)
2840#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_) \
2841 struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> { \
2842 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2843 static constexpr const char* mLabel = "fIndexSlice" _Label_; \
2844 using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>; \
2845 using type = _Type_[2]; \
2846 using column_t = _Name_##IdSlice; \
2847 using self_index_t = std::true_type; \
2848 using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>; \
2849 _Name_##IdSlice(arrow::ChunkedArray const* column) \
2850 : o2::soa::Column<_Type_[2], _Name_##IdSlice>(o2::soa::ColumnIterator<type>(column)) \
2851 { \
2852 } \
2853 \
2854 _Name_##IdSlice() = default; \
2855 _Name_##IdSlice(_Name_##IdSlice const& other) = default; \
2856 _Name_##IdSlice& operator=(_Name_##IdSlice const& other) = default; \
2857 std::array<_Type_, 2> inline getIds() const \
2858 { \
2859 return _Getter_##Ids(); \
2860 } \
2861 \
2862 bool has_##_Getter_() const \
2863 { \
2864 auto a = *mColumnIterator; \
2865 return a[0] >= 0 && a[1] >= 0; \
2866 } \
2867 \
2868 std::array<_Type_, 2> _Getter_##Ids() const \
2869 { \
2870 auto a = *mColumnIterator; \
2871 return std::array{a[0], a[1]}; \
2872 } \
2873 \
2874 template <typename T> \
2875 auto _Getter_##_as() const \
2876 { \
2877 auto t = mBinding.get<T>(); \
2878 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2879 o2::soa::dereferenceWithWrongType(#_Getter_, "self"); \
2880 } \
2881 if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) { \
2882 return t->emptySlice(); \
2883 } \
2884 auto a = *mColumnIterator; \
2885 auto r = t->rawSlice(a[0], a[1]); \
2886 t->copyIndexBindings(r); \
2887 r.bindInternalIndicesTo(t); \
2888 return r; \
2889 } \
2890 \
2891 bool setCurrentRaw(o2::soa::Binding current) \
2892 { \
2893 this->mBinding = current; \
2894 return true; \
2895 } \
2896 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2897 o2::soa::Binding mBinding; \
2898 };
2899
2900#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
2901#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, "_" #_Name_)
2903#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_) \
2904 struct _Name_##Ids : o2::soa::Column<std::vector<_Type_>, _Name_##Ids> { \
2905 static_assert(std::is_integral_v<_Type_>, "Index type must be integral"); \
2906 static constexpr const char* mLabel = "fIndexArray" _Label_; \
2907 using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>; \
2908 using type = std::vector<_Type_>; \
2909 using column_t = _Name_##Ids; \
2910 using self_index_t = std::true_type; \
2911 using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>; \
2912 _Name_##Ids(arrow::ChunkedArray const* column) \
2913 : o2::soa::Column<std::vector<_Type_>, _Name_##Ids>(o2::soa::ColumnIterator<type>(column)) \
2914 { \
2915 } \
2916 \
2917 _Name_##Ids() = default; \
2918 _Name_##Ids(_Name_##Ids const& other) = default; \
2919 _Name_##Ids& operator=(_Name_##Ids const& other) = default; \
2920 gsl::span<const _Type_> inline getIds() const \
2921 { \
2922 return _Getter_##Ids(); \
2923 } \
2924 \
2925 gsl::span<const _Type_> _Getter_##Ids() const \
2926 { \
2927 return *mColumnIterator; \
2928 } \
2929 \
2930 bool has_##_Getter_() const \
2931 { \
2932 return !(*mColumnIterator).empty(); \
2933 } \
2934 \
2935 template <typename T> \
2936 auto _Getter_##_as() const \
2937 { \
2938 auto t = mBinding.get<T>(); \
2939 if (O2_BUILTIN_UNLIKELY(t == nullptr)) { \
2940 o2::soa::dereferenceWithWrongType(#_Getter_, "self"); \
2941 } \
2942 return getIterators<T>(); \
2943 } \
2944 \
2945 template <typename T> \
2946 auto getIterators() const \
2947 { \
2948 auto result = std::vector<typename T::unfiltered_iterator>(); \
2949 for (auto& i : *mColumnIterator) { \
2950 result.push_back(mBinding.get<T>()->rawIteratorAt(i)); \
2951 } \
2952 return result; \
2953 } \
2954 \
2955 template <typename T> \
2956 auto _Getter_##_first_as() const \
2957 { \
2958 return mBinding.get<T>()->rawIteratorAt((*mColumnIterator)[0]); \
2959 } \
2960 \
2961 template <typename T> \
2962 auto _Getter_##_last_as() const \
2963 { \
2964 return mBinding.get<T>()->rawIteratorAt((*mColumnIterator).back()); \
2965 } \
2966 \
2967 bool setCurrentRaw(o2::soa::Binding current) \
2968 { \
2969 this->mBinding = current; \
2970 return true; \
2971 } \
2972 o2::soa::Binding getCurrentRaw() const { return mBinding; } \
2973 o2::soa::Binding mBinding; \
2974 };
2975
2976#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
2977#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, "_" #_Name_)
2978
3007#define DECLARE_SOA_DYNAMIC_COLUMN(_Name_, _Getter_, ...) \
3008 struct _Name_##Callback { \
3009 static inline constexpr auto getLambda() { return __VA_ARGS__; } \
3010 }; \
3011 \
3012 struct _Name_##Helper { \
3013 using callable_t = decltype(o2::framework::FunctionMetadata(std::declval<decltype(_Name_##Callback::getLambda())>())); \
3014 using return_type = typename callable_t::return_type; \
3015 }; \
3016 template <typename... Bindings> \
3017 struct _Name_ : o2::soa::DynamicColumn<typename _Name_##Helper::callable_t::type, _Name_<Bindings...>> { \
3018 using base = o2::soa::DynamicColumn<typename _Name_##Helper::callable_t::type, _Name_<Bindings...>>; \
3019 using helper = _Name_##Helper; \
3020 using callback_holder_t = _Name_##Callback; \
3021 using callable_t = helper::callable_t; \
3022 using callback_t = callable_t::type; \
3023 \
3024 _Name_(arrow::ChunkedArray const*) \
3025 { \
3026 } \
3027 _Name_() = default; \
3028 _Name_(_Name_ const& other) = default; \
3029 _Name_& operator=(_Name_ const& other) = default; \
3030 static constexpr const char* mLabel = #_Name_; \
3031 using type = typename callable_t::return_type; \
3032 \
3033 template <typename... FreeArgs> \
3034 type _Getter_(FreeArgs... freeArgs) const \
3035 { \
3036 return boundGetter(std::make_index_sequence<std::tuple_size_v<decltype(boundIterators)>>{}, freeArgs...); \
3037 } \
3038 template <typename... FreeArgs> \
3039 type getDynamicValue(FreeArgs... freeArgs) const \
3040 { \
3041 return boundGetter(std::make_index_sequence<std::tuple_size_v<decltype(boundIterators)>>{}, freeArgs...); \
3042 } \
3043 \
3044 type get() const \
3045 { \
3046 return _Getter_(); \
3047 } \
3048 \
3049 template <size_t... Is, typename... FreeArgs> \
3050 type boundGetter(std::integer_sequence<size_t, Is...>&&, FreeArgs... freeArgs) const \
3051 { \
3052 return __VA_ARGS__((**std::get<Is>(boundIterators))..., freeArgs...); \
3053 } \
3054 \
3055 using bindings_t = typename o2::framework::pack<Bindings...>; \
3056 std::tuple<o2::soa::ColumnIterator<typename Bindings::type> const*...> boundIterators; \
3057 }
3058
3059#define DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, ...) \
3060 using _Name_##Metadata = TableMetadata<Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__>;
3061
3062#define DECLARE_SOA_TABLE_METADATA_TRAIT(_Name_, _Desc_, _Version_) \
3063 template <> \
3064 struct MetadataTrait<Hash<_Desc_ "/" #_Version_ ""_h>> { \
3065 using metadata = _Name_##Metadata; \
3066 };
3067
3068#define DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, _Version_) \
3069 O2HASH(_Desc_ "/" #_Version_); \
3070 template <typename O> \
3071 using _Name_##From = o2::soa::Table<Hash<_Label_ ""_h>, Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
3072 using _Name_ = _Name_##From<Hash<_Origin_ ""_h>>; \
3073 template <> \
3074 struct MetadataTrait<Hash<_Desc_ "/" #_Version_ ""_h>> { \
3075 using metadata = _Name_##Metadata; \
3076 };
3077
3078#define DECLARE_SOA_STAGE(_Name_, _Origin_, _Desc_, _Version_) \
3079 template <typename O> \
3080 using _Name_##From = o2::soa::Table<Hash<#_Name_ ""_h>, Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
3081 using _Name_ = _Name_##From<Hash<_Origin_ ""_h>>;
3082
3083#define DECLARE_SOA_TABLE_FULL_VERSIONED(_Name_, _Label_, _Origin_, _Desc_, _Version_, ...) \
3084 DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, __VA_ARGS__); \
3085 DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, _Version_);
3086
3087#define DECLARE_SOA_TABLE_FULL(_Name_, _Label_, _Origin_, _Desc_, ...) \
3088 O2HASH(_Label_); \
3089 DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, 0, __VA_ARGS__); \
3090 DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, 0)
3091
3092#define DECLARE_SOA_TABLE(_Name_, _Origin_, _Desc_, ...) \
3093 DECLARE_SOA_TABLE_FULL(_Name_, #_Name_, _Origin_, _Desc_, __VA_ARGS__)
3094
3095#define DECLARE_SOA_TABLE_VERSIONED(_Name_, _Origin_, _Desc_, _Version_, ...) \
3096 O2HASH(#_Name_); \
3097 DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, __VA_ARGS__); \
3098 DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, #_Name_, _Origin_, _Desc_, _Version_)
3099
3100#define DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Desc_, _Version_, ...) \
3101 O2HASH(_Desc_ "/" #_Version_); \
3102 O2HASH(#_BaseName_); \
3103 O2HASH("Stored" #_BaseName_); \
3104 DECLARE_SOA_TABLE_METADATA(_BaseName_, _Desc_, _Version_, __VA_ARGS__); \
3105 using Stored##_BaseName_##Metadata = _BaseName_##Metadata; \
3106 DECLARE_SOA_TABLE_METADATA_TRAIT(_BaseName_, _Desc_, _Version_); \
3107 DECLARE_SOA_STAGE(_BaseName_, "AOD", _Desc_, _Version_); \
3108 DECLARE_SOA_STAGE(Stored##_BaseName_, "AOD1", _Desc_, _Version_);
3109
3110#define DECLARE_SOA_TABLE_STAGED(_BaseName_, _Desc_, ...) \
3111 DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Desc_, 0, __VA_ARGS__);
3112
3113#define DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...) \
3114 O2HASH(_Desc_ "/" #_Version_); \
3115 template <typename O> \
3116 using _Name_##ExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
3117 using _Name_##Extension = _Name_##ExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>; \
3118 template <typename O = o2::aod::Hash<_Origin_ ""_h>> \
3119 struct _Name_##ExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> { \
3120 using base_table_t = _OriginalTable_; \
3121 using extension_table_t = _Name_##ExtensionFrom<O>; \
3122 using expression_pack_t = framework::pack<__VA_ARGS__>; \
3123 static constexpr auto sources = _OriginalTable_::originals; \
3124 }; \
3125 using _Name_##ExtensionMetadata = _Name_##ExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>; \
3126 template <> \
3127 struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> { \
3128 using metadata = _Name_##ExtensionMetadata; \
3129 }; \
3130 template <typename O> \
3131 using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##ExtensionFrom<O>>; \
3132 using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
3133
3134#define DECLARE_SOA_EXTENDED_TABLE(_Name_, _Table_, _Description_, _Version_, ...) \
3135 O2HASH(#_Name_ "Extension"); \
3136 DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "DYN", _Description_, _Version_, __VA_ARGS__)
3137
3138#define DECLARE_SOA_EXTENDED_TABLE_USER(_Name_, _Table_, _Description_, ...) \
3139 O2HASH(#_Name_ "Extension"); \
3140 DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
3141
3142#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...) \
3143 O2HASH(_Desc_ "/" #_Version_); \
3144 template <typename O> \
3145 using _Name_##CfgExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
3146 using _Name_##CfgExtension = _Name_##CfgExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>; \
3147 template <typename O = o2::aod::Hash<_Origin_ ""_h>> \
3148 struct _Name_##CfgExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> { \
3149 using base_table_t = _OriginalTable_; \
3150 using extension_table_t = _Name_##CfgExtensionFrom<O>; \
3151 using placeholders_pack_t = framework::pack<__VA_ARGS__>; \
3152 using configurable_t = std::true_type; \
3153 static constexpr auto sources = _OriginalTable_::originals; \
3154 }; \
3155 using _Name_##CfgExtensionMetadata = _Name_##CfgExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>; \
3156 template <> \
3157 struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> { \
3158 using metadata = _Name_##CfgExtensionMetadata; \
3159 }; \
3160 template <typename O> \
3161 using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##CfgExtensionFrom<O>>; \
3162 using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
3163
3164#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(_Name_, _Table_, _Description_, ...) \
3165 O2HASH(#_Name_ "CfgExtension"); \
3166 DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, #_Name_ "CfgExtension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
3167
3168#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...) \
3169 O2HASH(#_Name_); \
3170 O2HASH(_Desc_ "/" #_Version_); \
3171 template <typename O = o2::aod::Hash<_Origin_ ""_h>> \
3172 struct _Name_##MetadataFrom : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> { \
3173 static constexpr bool exclusive = _Exclusive_; \
3174 using Key = _Key_; \
3175 using index_pack_t = framework::pack<__VA_ARGS__>; \
3176 static constexpr const auto sources = []<typename... Cs>(framework::pack<Cs...>) { \
3177 constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>(); \
3178 return o2::aod::filterForKey<a.size(), a, Key>(); \
3179 }(framework::pack<__VA_ARGS__>{}); \
3180 }; \
3181 using _Name_##Metadata = _Name_##MetadataFrom<o2::aod::Hash<_Origin_ ""_h>>; \
3182 \
3183 template <typename O = o2::aod::Hash<_Origin_ ""_h>> \
3184 using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_, __VA_ARGS__>; \
3185 using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>; \
3186 \
3187 template <> \
3188 struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> { \
3189 using metadata = _Name_##Metadata; \
3190 };
3191
3192#define DECLARE_SOA_INDEX_TABLE(_Name_, _Key_, _Description_, ...) \
3193 DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, false, __VA_ARGS__)
3194
3195#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(_Name_, _Key_, _Description_, ...) \
3196 DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, true, __VA_ARGS__)
3197
3198#define DECLARE_SOA_INDEX_TABLE_USER(_Name_, _Key_, _Description_, ...) \
3199 DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, false, __VA_ARGS__)
3200
3201#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE_USER(_Name_, _Key_, _Description_, ...) \
3202 DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, true, __VA_ARGS__)
3203
3204namespace o2::soa
3205{
3206template <typename D, typename... Ts>
3207struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...> {
3208 using base = Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...>;
3209
3210 JoinFull(std::shared_ptr<arrow::Table>&& table, uint64_t offset = 0)
3211 : base{std::move(table), offset}
3212 {
3214 }
3215 JoinFull(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
3216 : base{ArrowHelpers::joinTables(std::move(tables)), offset}
3217 {
3219 }
3222
3223 using self_t = JoinFull<D, Ts...>;
3224 using table_t = base;
3225 static constexpr const auto originals = base::originals;
3228 using iterator = table_t::template iterator_template<DefaultIndexPolicy, self_t, Ts...>;
3234
3236 {
3237 return iterator{this->cached_begin()};
3238 }
3239
3241 {
3242 return const_iterator{this->cached_begin()};
3243 }
3244
3246 {
3247 return doSliceByCached(this, node, value, cache);
3248 }
3249
3251 {
3252 return doSliceByCachedUnsorted(this, node, value, cache);
3253 }
3254
3255 template <typename T1, typename Policy, bool OPT>
3257 {
3258 return doSliceBy(this, container, value);
3259 }
3260
3261 iterator rawIteratorAt(uint64_t i) const
3262 {
3263 auto it = iterator{this->cached_begin()};
3264 it.setCursor(i);
3265 return it;
3266 }
3267
3268 iterator iteratorAt(uint64_t i) const
3269 {
3270 return rawIteratorAt(i);
3271 }
3272
3273 auto rawSlice(uint64_t start, uint64_t end) const
3274 {
3275 return self_t{{this->asArrowTable()->Slice(start, end - start + 1)}, start};
3276 }
3277
3278 auto emptySlice() const
3279 {
3280 return self_t{{this->asArrowTable()->Slice(0, 0)}, 0};
3281 }
3282
3283 template <typename T>
3284 static consteval bool contains()
3285 {
3286 return std::find_if(originals.begin(), originals.end(), [](TableRef const& ref) { return ref.desc_hash == T::ref.desc_hash; }) != originals.end();
3287 }
3288};
3289
3290template <typename... Ts>
3291using Join = JoinFull<o2::aod::Hash<"JOIN/0"_h>, Ts...>;
3292
3293template <typename... Ts>
3294constexpr auto join(Ts const&... t)
3295{
3296 return Join<Ts...>(ArrowHelpers::joinTables({t.asArrowTable()...}));
3297}
3298
3299template <typename T>
3301
3302template <typename T>
3303constexpr bool is_soa_join_v = is_join<T>;
3304
3305template <typename... Ts>
3306struct Concat : Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::aod::Hash<"CONC"_h>, Ts...> {
3307 using base = Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::aod::Hash<"CONC"_h>, Ts...>;
3308 using self_t = Concat<Ts...>;
3309 Concat(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
3310 : base{ArrowHelpers::concatTables(std::move(tables)), offset}
3311 {
3313 }
3314 Concat(Ts const&... t, uint64_t offset = 0)
3315 : base{ArrowHelpers::concatTables({t.asArrowTable()...}), offset}
3316 {
3317 bindInternalIndicesTo(this);
3318 }
3319
3320 using base::originals;
3321
3322 using base::bindExternalIndices;
3323 using base::bindInternalIndicesTo;
3324
3325 using table_t = base;
3328
3329 using iterator = table_t::template iterator_template<DefaultIndexPolicy, self_t, Ts...>;
3335};
3336
3337template <typename... Ts>
3338constexpr auto concat(Ts const&... t)
3339{
3340 return Concat<Ts...>{t...};
3341}
3342
3343template <soa::is_table T>
3344class FilteredBase : public T
3345{
3346 public:
3348 using table_t = typename T::table_t;
3349 using T::originals;
3350 using columns_t = typename T::columns_t;
3351 using persistent_columns_t = typename T::persistent_columns_t;
3352 using external_index_columns_t = typename T::external_index_columns_t;
3353
3354 using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
3355 using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
3357
3358 FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gandiva::Selection const& selection, uint64_t offset = 0)
3359 : T{std::move(tables), offset},
3360 mSelectedRows{getSpan(selection)}
3361 {
3362 if (this->tableSize() != 0) {
3363 mFilteredBegin = table_t::filtered_begin(mSelectedRows);
3364 }
3365 resetRanges();
3366 mFilteredBegin.bindInternalIndices(this);
3367 }
3368
3369 FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
3370 : T{std::move(tables), offset},
3371 mSelectedRowsCache{std::move(selection)},
3372 mCached{true}
3373 {
3374 mSelectedRows = gsl::span{mSelectedRowsCache};
3375 if (this->tableSize() != 0) {
3376 mFilteredBegin = table_t::filtered_begin(mSelectedRows);
3377 }
3378 resetRanges();
3379 mFilteredBegin.bindInternalIndices(this);
3380 }
3381
3382 FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
3383 : T{std::move(tables), offset},
3384 mSelectedRows{selection}
3385 {
3386 if (this->tableSize() != 0) {
3387 mFilteredBegin = table_t::filtered_begin(mSelectedRows);
3388 }
3389 resetRanges();
3390 mFilteredBegin.bindInternalIndices(this);
3391 }
3392
3394 {
3395 return iterator(mFilteredBegin);
3396 }
3397
3399 {
3400 return const_iterator(mFilteredBegin);
3401 }
3402
3404 {
3405 auto it = unfiltered_iterator{mFilteredBegin};
3406 it.setCursor(i);
3407 return it;
3408 }
3409
3410 [[nodiscard]] RowViewSentinel end() const
3411 {
3412 return RowViewSentinel{*mFilteredEnd};
3413 }
3414
3416 {
3417 return mFilteredBegin;
3418 }
3419
3420 auto const& cached_begin() const
3421 {
3422 return mFilteredBegin;
3423 }
3424
3425 iterator iteratorAt(uint64_t i) const
3426 {
3427 return mFilteredBegin + i;
3428 }
3429
3430 [[nodiscard]] int64_t size() const
3431 {
3432 return mSelectedRows.size();
3433 }
3434
3435 [[nodiscard]] int64_t tableSize() const
3436 {
3437 return table_t::asArrowTable()->num_rows();
3438 }
3439
3440 auto const& getSelectedRows() const
3441 {
3442 return mSelectedRows;
3443 }
3444
3445 auto rawSlice(uint64_t start, uint64_t end) const
3446 {
3447 SelectionVector newSelection;
3448 newSelection.resize(static_cast<int64_t>(end - start + 1));
3449 std::iota(newSelection.begin(), newSelection.end(), start);
3450 return self_t{{this->asArrowTable()}, std::move(newSelection), 0};
3451 }
3452
3453 auto emptySlice() const
3454 {
3455 return self_t{{this->asArrowTable()}, SelectionVector{}, 0};
3456 }
3457
3458 static inline auto getSpan(gandiva::Selection const& sel)
3459 {
3460 if (sel == nullptr) {
3461 return gsl::span<int64_t const>{};
3462 }
3463 auto array = std::static_pointer_cast<arrow::Int64Array>(sel->ToArray());
3464 auto start = array->raw_values();
3465 auto stop = start + array->length();
3466 return gsl::span{start, stop};
3467 }
3468
3471 template <typename... TA>
3472 void bindExternalIndices(TA*... current)
3473 {
3474 table_t::bindExternalIndices(current...);
3475 mFilteredBegin.bindExternalIndices(current...);
3476 }
3477
3478 void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
3479 {
3480 mFilteredBegin.bindExternalIndicesRaw(std::forward<std::vector<o2::soa::Binding>>(ptrs));
3481 }
3482
3483 template <typename I>
3485 {
3486 mFilteredBegin.bindInternalIndices(ptr);
3487 }
3488
3489 template <typename T1, typename... Cs>
3491 {
3492 dest.bindExternalIndicesRaw(mFilteredBegin.getIndexBindings());
3493 }
3494
3495 template <typename T1>
3496 void copyIndexBindings(T1& dest) const
3497 {
3498 doCopyIndexBindings(external_index_columns_t{}, dest);
3499 }
3500
3501 template <typename T1>
3502 auto rawSliceBy(o2::framework::Preslice<T1> const& container, int value) const
3503 {
3504 return (table_t)this->sliceBy(container, value);
3505 }
3506
3508 {
3509 return doFilteredSliceByCached(this, node, value, cache);
3510 }
3511
3513 {
3514 return doSliceByCachedUnsorted(this, node, value, cache);
3515 }
3516
3517 template <typename T1, bool OPT>
3519 {
3520 return doFilteredSliceBy(this, container, value);
3521 }
3522
3523 template <typename T1, bool OPT>
3525 {
3526 return doSliceBy(this, container, value);
3527 }
3528
3530 {
3531 auto t = o2::soa::select(*this, f);
3532 copyIndexBindings(t);
3533 return t;
3534 }
3535
3536 int isInSelectedRows(int i) const
3537 {
3538 auto locate = std::find(mSelectedRows.begin(), mSelectedRows.end(), i);
3539 if (locate == mSelectedRows.end()) {
3540 return -1;
3541 }
3542 return static_cast<int>(std::distance(mSelectedRows.begin(), locate));
3543 }
3544
3545 void sumWithSelection(SelectionVector const& selection)
3546 {
3547 mCached = true;
3548 SelectionVector rowsUnion;
3549 std::set_union(mSelectedRows.begin(), mSelectedRows.end(), selection.begin(), selection.end(), std::back_inserter(rowsUnion));
3550 mSelectedRowsCache.clear();
3551 mSelectedRowsCache = rowsUnion;
3552 resetRanges();
3553 }
3554
3556 {
3557 mCached = true;
3558 SelectionVector intersection;
3559 std::set_intersection(mSelectedRows.begin(), mSelectedRows.end(), selection.begin(), selection.end(), std::back_inserter(intersection));
3560 mSelectedRowsCache.clear();
3561 mSelectedRowsCache = intersection;
3562 resetRanges();
3563 }
3564
3565 void sumWithSelection(gsl::span<int64_t const> const& selection)
3566 {
3567 mCached = true;
3568 SelectionVector rowsUnion;
3569 std::set_union(mSelectedRows.begin(), mSelectedRows.end(), selection.begin(), selection.end(), std::back_inserter(rowsUnion));
3570 mSelectedRowsCache.clear();
3571 mSelectedRowsCache = rowsUnion;
3572 resetRanges();
3573 }
3574
3575 void intersectWithSelection(gsl::span<int64_t const> const& selection)
3576 {
3577 mCached = true;
3578 SelectionVector intersection;
3579 std::set_intersection(mSelectedRows.begin(), mSelectedRows.end(), selection.begin(), selection.end(), std::back_inserter(intersection));
3580 mSelectedRowsCache.clear();
3581 mSelectedRowsCache = intersection;
3582 resetRanges();
3583 }
3584
3585 bool isCached() const
3586 {
3587 return mCached;
3588 }
3589
3590 private:
3591 void resetRanges()
3592 {
3593 if (mCached) {
3594 mSelectedRows = gsl::span{mSelectedRowsCache};
3595 }
3596 mFilteredEnd.reset(new RowViewSentinel{static_cast<int64_t>(mSelectedRows.size())});
3597 if (tableSize() == 0) {
3598 mFilteredBegin = *mFilteredEnd;
3599 } else {
3600 mFilteredBegin.resetSelection(mSelectedRows);
3601 }
3602 }
3603
3604 gsl::span<int64_t const> mSelectedRows;
3605 SelectionVector mSelectedRowsCache;
3606 bool mCached = false;
3607 iterator mFilteredBegin;
3608 std::shared_ptr<RowViewSentinel> mFilteredEnd;
3609};
3610
3611template <typename T>
3612class Filtered : public FilteredBase<T>
3613{
3614 public:
3615 using base_t = T;
3617 using table_t = typename T::table_t;
3618 using columns_t = typename T::columns_t;
3619
3620 using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
3621 using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
3623
3625 {
3626 return iterator(this->cached_begin());
3627 }
3628
3630 {
3631 return const_iterator(this->cached_begin());
3632 }
3633
3634 Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, gandiva::Selection const& selection, uint64_t offset = 0)
3635 : FilteredBase<T>(std::move(tables), selection, offset) {}
3636
3637 Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
3638 : FilteredBase<T>(std::move(tables), std::forward<SelectionVector>(selection), offset) {}
3639
3640 Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
3641 : FilteredBase<T>(std::move(tables), selection, offset) {}
3642
3644 {
3645 Filtered<T> copy(*this);
3646 copy.sumWithSelection(selection);
3647 return copy;
3648 }
3649
3650 Filtered<T> operator+(gsl::span<int64_t const> const& selection)
3651 {
3652 Filtered<T> copy(*this);
3653 copy.sumWithSelection(selection);
3654 return copy;
3655 }
3656
3658 {
3659 return operator+(other.getSelectedRows());
3660 }
3661
3663 {
3664 this->sumWithSelection(selection);
3665 return *this;
3666 }
3667
3668 Filtered<T> operator+=(gsl::span<int64_t const> const& selection)
3669 {
3670 this->sumWithSelection(selection);
3671 return *this;
3672 }
3673
3675 {
3676 return operator+=(other.getSelectedRows());
3677 }
3678
3680 {
3681 Filtered<T> copy(*this);
3682 copy.intersectWithSelection(selection);
3683 return copy;
3684 }
3685
3686 Filtered<T> operator*(gsl::span<int64_t const> const& selection)
3687 {
3688 Filtered<T> copy(*this);
3689 copy.intersectWithSelection(selection);
3690 return copy;
3691 }
3692
3694 {
3695 return operator*(other.getSelectedRows());
3696 }
3697
3699 {
3700 this->intersectWithSelection(selection);
3701 return *this;
3702 }
3703
3704 Filtered<T> operator*=(gsl::span<int64_t const> const& selection)
3705 {
3706 this->intersectWithSelection(selection);
3707 return *this;
3708 }
3709
3711 {
3712 return operator*=(other.getSelectedRows());
3713 }
3714
3716 {
3717 auto it = unfiltered_iterator{this->cached_begin()};
3718 it.setCursor(i);
3719 return it;
3720 }
3721
3722 using FilteredBase<T>::getSelectedRows;
3723
3724 auto rawSlice(uint64_t start, uint64_t end) const
3725 {
3726 SelectionVector newSelection;
3727 newSelection.resize(static_cast<int64_t>(end - start + 1));
3728 std::iota(newSelection.begin(), newSelection.end(), start);
3729 return self_t{{this->asArrowTable()}, std::move(newSelection), 0};
3730 }
3731
3732 auto emptySlice() const
3733 {
3734 return self_t{{this->asArrowTable()}, SelectionVector{}, 0};
3735 }
3736
3737 template <typename T1>
3738 auto rawSliceBy(o2::framework::Preslice<T1> const& container, int value) const
3739 {
3740 return (table_t)this->sliceBy(container, value);
3741 }
3742
3744 {
3745 return doFilteredSliceByCached(this, node, value, cache);
3746 }
3747
3749 {
3750 return doSliceByCachedUnsorted(this, node, value, cache);
3751 }
3752
3753 template <typename T1, bool OPT>
3755 {
3756 return doFilteredSliceBy(this, container, value);
3757 }
3758
3759 template <typename T1, bool OPT>
3761 {
3762 return doSliceBy(this, container, value);
3763 }
3764
3766 {
3767 auto t = o2::soa::select(*this, f);
3768 copyIndexBindings(t);
3769 return t;
3770 }
3771};
3772
3773template <typename T>
3774class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
3775{
3776 public:
3778 using base_t = T;
3780 using columns_t = typename T::columns_t;
3781
3782 using iterator = typename T::template iterator_template_o<FilteredIndexPolicy, self_t>;
3783 using unfiltered_iterator = typename T::template iterator_template_o<DefaultIndexPolicy, self_t>;
3785
3787 {
3788 return iterator(this->cached_begin());
3789 }
3790
3792 {
3793 return const_iterator(this->cached_begin());
3794 }
3795
3796 Filtered(std::vector<Filtered<T>>&& tables, gandiva::Selection const& selection, uint64_t offset = 0)
3797 : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), selection, offset)
3798 {
3799 for (auto& table : tables) {
3800 *this *= table;
3801 }
3802 }
3803
3804 Filtered(std::vector<Filtered<T>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
3805 : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), std::forward<SelectionVector>(selection), offset)
3806 {
3807 for (auto& table : tables) {
3808 *this *= table;
3809 }
3810 }
3811
3812 Filtered(std::vector<Filtered<T>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
3813 : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), selection, offset)
3814 {
3815 for (auto& table : tables) {
3816 *this *= table;
3817 }
3818 }
3819
3821 {
3822 Filtered<Filtered<T>> copy(*this);
3823 copy.sumWithSelection(selection);
3824 return copy;
3825 }
3826
3827 Filtered<Filtered<T>> operator+(gsl::span<int64_t const> const& selection)
3828 {
3829 Filtered<Filtered<T>> copy(*this);
3830 copy.sumWithSelection(selection);
3831 return copy;
3832 }
3833
3835 {
3836 return operator+(other.getSelectedRows());
3837 }
3838
3840 {
3841 this->sumWithSelection(selection);
3842 return *this;
3843 }
3844
3845 Filtered<Filtered<T>> operator+=(gsl::span<int64_t const> const& selection)
3846 {
3847 this->sumWithSelection(selection);
3848 return *this;
3849 }
3850
3852 {
3853 return operator+=(other.getSelectedRows());
3854 }
3855
3857 {
3858 Filtered<Filtered<T>> copy(*this);
3859 copy.intersectionWithSelection(selection);
3860 return copy;
3861 }
3862
3863 Filtered<Filtered<T>> operator*(gsl::span<int64_t const> const& selection)
3864 {
3865 Filtered<Filtered<T>> copy(*this);
3866 copy.intersectionWithSelection(selection);
3867 return copy;
3868 }
3869
3871 {
3872 return operator*(other.getSelectedRows());
3873 }
3874
3876 {
3877 this->intersectWithSelection(selection);
3878 return *this;
3879 }
3880
3881 Filtered<Filtered<T>> operator*=(gsl::span<int64_t const> const& selection)
3882 {
3883 this->intersectWithSelection(selection);
3884 return *this;
3885 }
3886
3888 {
3889 return operator*=(other.getSelectedRows());
3890 }
3891
3893 {
3894 auto it = unfiltered_iterator{this->cached_begin()};
3895 it.setCursor(i);
3896 return it;
3897 }
3898
3899 auto rawSlice(uint64_t start, uint64_t end) const
3900 {
3901 SelectionVector newSelection;
3902 newSelection.resize(static_cast<int64_t>(end - start + 1));
3903 std::iota(newSelection.begin(), newSelection.end(), start);
3904 return self_t{{this->asArrowTable()}, std::move(newSelection), 0};
3905 }
3906
3907 auto emptySlice() const
3908 {
3909 return self_t{{this->asArrowTable()}, SelectionVector{}, 0};
3910 }
3911
3913 {
3914 return doFilteredSliceByCached(this, node, value, cache);
3915 }
3916
3918 {
3919 return doSliceByCachedUnsorted(this, node, value, cache);
3920 }
3921
3922 template <typename T1, bool OPT>
3924 {
3925 return doFilteredSliceBy(this, container, value);
3926 }
3927
3928 template <typename T1, bool OPT>
3930 {
3931 return doSliceBy(this, container, value);
3932 }
3933
3934 private:
3935 std::vector<std::shared_ptr<arrow::Table>> extractTablesFromFiltered(std::vector<Filtered<T>>& tables)
3936 {
3937 std::vector<std::shared_ptr<arrow::Table>> outTables;
3938 for (auto& table : tables) {
3939 outTables.push_back(table.asArrowTable());
3940 }
3941 return outTables;
3942 }
3943};
3944
3950template <typename L, typename D, typename O, typename Key, typename H, typename... Ts>
3951struct IndexTable : Table<L, D, O> {
3952 using self_t = IndexTable<L, D, O, Key, H, Ts...>;
3957 using first_t = typename H::binding_t;
3958 using rest_t = framework::pack<typename Ts::binding_t...>;
3959
3960 IndexTable(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
3961 : base_t{table, offset}
3962 {
3963 }
3964
3965 IndexTable(std::vector<std::shared_ptr<arrow::Table>> tables, uint64_t offset = 0)
3966 : base_t{tables[0], offset}
3967 {
3968 }
3969
3970 IndexTable(IndexTable const&) = default;
3972 IndexTable& operator=(IndexTable const&) = default;
3974
3979};
3980
3981template <typename T, bool APPLY>
3982struct SmallGroupsBase : public Filtered<T> {
3983 static constexpr bool applyFilters = APPLY;
3984 SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gandiva::Selection const& selection, uint64_t offset = 0)
3985 : Filtered<T>(std::move(tables), selection, offset) {}
3986
3987 SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
3988 : Filtered<T>(std::move(tables), std::forward<SelectionVector>(selection), offset) {}
3989
3990 SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
3991 : Filtered<T>(std::move(tables), selection, offset) {}
3992};
3993
3994template <typename T>
3996
3997template <typename T>
3999
4000template <typename T>
4001concept is_smallgroups = requires {
4002 []<typename B, bool A>(SmallGroupsBase<B, A>*) {}(std::declval<T*>());
4003};
4004} // namespace o2::soa
4005
4006#endif // O2_FRAMEWORK_ASOA_H_
#define O2HASH(_Str_)
Pre-declare Hash specialization for a generic string.
Definition ASoA.h:276
#define O2ORIGIN(_Str_)
Pre-declare Hash specialization for an origin string.
Definition ASoA.h:284
consteval auto getIndexTargets()
SLICE.
Definition ASoA.h:2453
o2::monitoring::tags::Key Key
#define O2_BUILTIN_UNREACHABLE
#define O2_BUILTIN_LIKELY(x)
#define O2_BUILTIN_UNLIKELY(x)
Hit operator+(const Hit &lhs, const Hit &rhs)
Definition Hit.cxx:46
int32_t i
bool o
uint16_t pos
Definition RawData.h:3
uint32_t res
Definition RawData.h:0
uint32_t c
Definition RawData.h:2
uint32_t version
Definition RawData.h:8
TBranch * ptr
void merge(Options const &options)
StringRef key
Definition A.h:16
Definition B.h:16
Class for time synchronization of RawReader instances.
int64_t const * mCurrentPos
Definition ASoA.h:595
ColumnIterator(arrow::ChunkedArray const *column)
Definition ASoA.h:496
ColumnIterator(ColumnIterator< T, ChunkingPolicy > const &)=default
void moveToEnd()
Move the iterator to the end of the column.
Definition ASoA.h:554
ColumnIterator< T > & moveToPos()
Definition ASoA.h:588
ColumnIterator< T, ChunkingPolicy > & operator=(ColumnIterator< T, ChunkingPolicy > const &)=default
unwrap_t< T > const * mCurrent
Definition ASoA.h:594
unwrap_t< T > const * mLast
Definition ASoA.h:596
ColumnIterator(ColumnIterator< T, ChunkingPolicy > &&)=default
void prevChunk() const
Definition ASoA.h:529
arrow::ChunkedArray const * mColumn
Definition ASoA.h:597
ColumnIterator< T, ChunkingPolicy > & operator=(ColumnIterator< T, ChunkingPolicy > &&)=default
void moveToChunk(int chunk)
Definition ASoA.h:540
void nextChunk() const
Move the iterator to the next chunk.
Definition ASoA.h:518
bool isCached() const
Definition ASoA.h:3585
auto sliceByCachedUnsorted(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3512
FilteredBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, gsl::span< int64_t const > const &selection, uint64_t offset=0)
Definition ASoA.h:3382
int64_t tableSize() const
Definition ASoA.h:3435
FilteredBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, gandiva::Selection const &selection, uint64_t offset=0)
Definition ASoA.h:3358
auto & cached_begin()
Definition ASoA.h:3415
typename T::external_index_columns_t external_index_columns_t
Definition ASoA.h:3352
auto select(framework::expressions::Filter const &f) const
Definition ASoA.h:3529
static auto getSpan(gandiva::Selection const &sel)
Definition ASoA.h:3458
int64_t size() const
Definition ASoA.h:3430
T::template iterator_template_o< FilteredIndexPolicy, self_t > iterator
Definition ASoA.h:3354
auto rawSliceBy(o2::framework::Preslice< T1 > const &container, int value) const
Definition ASoA.h:3502
T::template iterator_template_o< DefaultIndexPolicy, self_t > unfiltered_iterator
Definition ASoA.h:3355
void copyIndexBindings(T1 &dest) const
Definition ASoA.h:3496
auto const & getSelectedRows() const
Definition ASoA.h:3440
typename T::columns_t columns_t
Definition ASoA.h:3350
auto emptySlice() const
Definition ASoA.h:3453
void bindExternalIndices(TA *... current)
Definition ASoA.h:3472
void sumWithSelection(SelectionVector const &selection)
Definition ASoA.h:3545
void bindInternalIndicesTo(I const *ptr)
Definition ASoA.h:3484
void intersectWithSelection(SelectionVector const &selection)
Definition ASoA.h:3555
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicyGeneral, OPT > const &container, int value) const
Definition ASoA.h:3524
auto rawSlice(uint64_t start, uint64_t end) const
Definition ASoA.h:3445
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicySorted, OPT > const &container, int value) const
Definition ASoA.h:3518
iterator iteratorAt(uint64_t i) const
Definition ASoA.h:3425
iterator const_iterator
Definition ASoA.h:3356
typename T::table_t table_t
Definition ASoA.h:3348
typename T::persistent_columns_t persistent_columns_t
Definition ASoA.h:3351
RowViewSentinel end() const
Definition ASoA.h:3410
void intersectWithSelection(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3575
FilteredBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, SelectionVector &&selection, uint64_t offset=0)
Definition ASoA.h:3369
void bindExternalIndicesRaw(std::vector< o2::soa::Binding > &&ptrs)
Definition ASoA.h:3478
const_iterator begin() const
Definition ASoA.h:3398
unfiltered_iterator rawIteratorAt(uint64_t i) const
Definition ASoA.h:3403
int isInSelectedRows(int i) const
Definition ASoA.h:3536
auto sliceByCached(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3507
void doCopyIndexBindings(framework::pack< Cs... >, T1 &dest) const
Definition ASoA.h:3490
void sumWithSelection(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3565
iterator begin()
Definition ASoA.h:3393
auto const & cached_begin() const
Definition ASoA.h:3420
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicySorted, OPT > const &container, int value) const
Definition ASoA.h:3923
typename FilteredBase< typename T::table_t >::table_t table_t
Definition ASoA.h:3779
Filtered< Filtered< T > > operator+=(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3845
typename T::template iterator_template_o< DefaultIndexPolicy, self_t > unfiltered_iterator
Definition ASoA.h:3783
Filtered< Filtered< T > > operator+(SelectionVector const &selection)
Definition ASoA.h:3820
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicyGeneral, OPT > const &container, int value) const
Definition ASoA.h:3929
Filtered< Filtered< T > > operator*(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3863
typename T::template iterator_template_o< FilteredIndexPolicy, self_t > iterator
Definition ASoA.h:3782
typename T::columns_t columns_t
Definition ASoA.h:3780
const_iterator begin() const
Definition ASoA.h:3791
Filtered(std::vector< Filtered< T > > &&tables, SelectionVector &&selection, uint64_t offset=0)
Definition ASoA.h:3804
unfiltered_iterator rawIteratorAt(uint64_t i) const
Definition ASoA.h:3892
Filtered< Filtered< T > > operator+=(Filtered< T > const &other)
Definition ASoA.h:3851
Filtered< Filtered< T > > operator+=(SelectionVector const &selection)
Definition ASoA.h:3839
Filtered< Filtered< T > > operator*=(SelectionVector const &selection)
Definition ASoA.h:3875
auto rawSlice(uint64_t start, uint64_t end) const
Definition ASoA.h:3899
Filtered< Filtered< T > > operator+(Filtered< T > const &other)
Definition ASoA.h:3834
Filtered(std::vector< Filtered< T > > &&tables, gandiva::Selection const &selection, uint64_t offset=0)
Definition ASoA.h:3796
Filtered< Filtered< T > > operator*=(Filtered< T > const &other)
Definition ASoA.h:3887
auto sliceByCached(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3912
Filtered< Filtered< T > > operator*=(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3881
Filtered< Filtered< T > > operator*(Filtered< T > const &other)
Definition ASoA.h:3870
Filtered< Filtered< T > > operator+(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3827
Filtered< Filtered< T > > operator*(SelectionVector const &selection)
Definition ASoA.h:3856
auto sliceByCachedUnsorted(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3917
Filtered(std::vector< Filtered< T > > &&tables, gsl::span< int64_t const > const &selection, uint64_t offset=0)
Definition ASoA.h:3812
Filtered< T > operator+=(Filtered< T > const &other)
Definition ASoA.h:3674
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicyGeneral, OPT > const &container, int value) const
Definition ASoA.h:3760
Filtered(std::vector< std::shared_ptr< arrow::Table > > &&tables, SelectionVector &&selection, uint64_t offset=0)
Definition ASoA.h:3637
iterator const_iterator
Definition ASoA.h:3622
Filtered(std::vector< std::shared_ptr< arrow::Table > > &&tables, gsl::span< int64_t const > const &selection, uint64_t offset=0)
Definition ASoA.h:3640
iterator begin()
Definition ASoA.h:3624
auto sliceByCachedUnsorted(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3748
Filtered< T > operator+(Filtered< T > const &other)
Definition ASoA.h:3657
Filtered< T > operator*=(SelectionVector const &selection)
Definition ASoA.h:3698
auto emptySlice() const
Definition ASoA.h:3732
const_iterator begin() const
Definition ASoA.h:3629
T::template iterator_template_o< FilteredIndexPolicy, self_t > iterator
Definition ASoA.h:3620
auto sliceByCached(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3743
auto select(framework::expressions::Filter const &f) const
Definition ASoA.h:3765
Filtered< T > operator+(SelectionVector const &selection)
Definition ASoA.h:3643
Filtered< T > operator*(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3686
T::template iterator_template_o< DefaultIndexPolicy, self_t > unfiltered_iterator
Definition ASoA.h:3621
unfiltered_iterator rawIteratorAt(uint64_t i) const
Definition ASoA.h:3715
Filtered< T > operator*(SelectionVector const &selection)
Definition ASoA.h:3679
Filtered< T > operator*=(Filtered< T > const &other)
Definition ASoA.h:3710
Filtered< T > operator*(Filtered< T > const &other)
Definition ASoA.h:3693
auto rawSliceBy(o2::framework::Preslice< T1 > const &container, int value) const
Definition ASoA.h:3738
Filtered< T > operator+=(SelectionVector const &selection)
Definition ASoA.h:3662
Filtered< T > operator*=(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3704
Filtered< T > operator+(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3650
Filtered< T > operator+=(gsl::span< int64_t const > const &selection)
Definition ASoA.h:3668
auto rawSlice(uint64_t start, uint64_t end) const
Definition ASoA.h:3724
Filtered(std::vector< std::shared_ptr< arrow::Table > > &&tables, gandiva::Selection const &selection, uint64_t offset=0)
Definition ASoA.h:3634
auto sliceBy(o2::framework::PresliceBase< T1, framework::PreslicePolicySorted, OPT > const &container, int value) const
Definition ASoA.h:3754
typename T::table_t table_t
Definition ASoA.h:3617
typename T::columns_t columns_t
Definition ASoA.h:3618
decltype([]< typename... C >(framework::pack< C... > &&) -> framework::selected_pack< soa::is_self_index_t, C... > {}(columns_t{})) internal_index_columns_t
Definition ASoA.h:1723
void bindInternalIndicesExplicit(o2::soa::Binding binding)
Definition ASoA.h:2050
auto & cached_begin()
Definition ASoA.h:1964
iterator iteratorAt(uint64_t i) const
Definition ASoA.h:1993
decltype([]< typename... C >(framework::pack< C... > &&) -> framework::selected_pack< soa::is_persistent_column_t, C... > {}(columns_t{})) persistent_columns_t
Definition ASoA.h:1719
static constexpr const auto ref
Definition ASoA.h:1681
auto offset() const
Return offset.
Definition ASoA.h:2021
static consteval bool hasOriginal()
Definition ASoA.h:1712
unfiltered_iterator begin()
Definition ASoA.h:1974
int64_t tableSize() const
Definition ASoA.h:2031
auto rawSlice(uint64_t start, uint64_t end) const
Definition ASoA.h:2101
void bindExternalIndices(TA *... current)
Definition ASoA.h:2039
auto select(framework::expressions::Filter const &f) const
Definition ASoA.h:2078
unfiltered_iterator unfiltered_const_iterator
Definition ASoA.h:1905
static consteval auto full_iter()
Definition ASoA.h:1884
auto const & cached_begin() const
Definition ASoA.h:1969
auto emptySlice() const
Definition ASoA.h:2106
auto sliceByCachedUnsorted(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:2090
void bindExternalIndicesRaw(std::vector< o2::soa::Binding > &&ptrs)
Definition ASoA.h:2061
auto sliceBy(o2::framework::PresliceBase< T1, Policy, OPT > const &container, int value) const
Definition ASoA.h:2096
static constexpr auto hashes()
Definition ASoA.h:1907
iterator unfiltered_iterator
Definition ASoA.h:1903
std::shared_ptr< arrow::Table > asArrowTable() const
Return a type erased arrow table backing store for / the type safe table.
Definition ASoA.h:2016
void doCopyIndexBindings(framework::pack< Cs... >, T &dest) const
Definition ASoA.h:2067
int64_t size() const
Size of the table, in rows.
Definition ASoA.h:2026
Table(std::vector< std::shared_ptr< arrow::Table > > &&tables, uint64_t offset=0)
Definition ASoA.h:1938
decltype(getColumns< ref, Ts... >()) columns_t
Definition ASoA.h:1717
arrow::ChunkedArray * getIndexToKey()
Definition ASoA.h:1945
RowViewSentinel end()
Definition ASoA.h:1979
decltype([]< typename... C >(framework::pack< C... >) -> framework::pack< typename C::type... > {}(persistent_columns_t{})) column_types
Definition ASoA.h:1720
static consteval auto isIndexTargetOf()
Definition ASoA.h:1689
iterator_template_o< FilteredIndexPolicy, table_t > filtered_iterator
Definition ASoA.h:1901
unfiltered_const_iterator begin() const
Definition ASoA.h:2005
void copyIndexBindings(T &dest) const
Definition ASoA.h:2073
Table(std::vector< std::shared_ptr< arrow::Table > > &&tables, uint64_t offset=0)
Definition ASoA.h:1932
Table< L, D, O, Ts... > self_t
Definition ASoA.h:1682
static consteval auto isIndexTargetOf()
Definition ASoA.h:1696
decltype(full_iter< IP, Parent >()) iterator_template_o
Definition ASoA.h:1898
void doBindInternalIndicesExplicit(framework::pack< Cs... >, o2::soa::Binding binding)
Definition ASoA.h:2056
static constexpr const auto originals
Definition ASoA.h:1685
decltype([]< typename... C >(framework::pack< C... > &&) -> framework::selected_pack< soa::is_external_index_t, C... > {}(columns_t{})) external_index_columns_t
Definition ASoA.h:1722
Table(std::shared_ptr< arrow::Table > table, uint64_t offset=0)
Definition ASoA.h:1912
RowViewSentinel end() const
Definition ASoA.h:2010
auto sliceByCached(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:2085
void bindInternalIndicesTo(I const *ptr)
Definition ASoA.h:2045
unfiltered_iterator rawIteratorAt(uint64_t i) const
Definition ASoA.h:1998
filtered_iterator filtered_begin(gsl::span< int64_t const > selection)
Definition ASoA.h:1984
iterator_template_o< DefaultIndexPolicy, table_t > iterator
Definition ASoA.h:1900
hash identification concepts
Definition ASoA.h:363
Helper to check if a type T is an iterator.
Definition ASoA.h:1254
column identification concepts
Definition ASoA.h:185
GLint GLenum GLint x
Definition glcorearb.h:403
GLenum func
Definition glcorearb.h:778
GLint GLsizei count
Definition glcorearb.h:399
GLsizeiptr size
Definition glcorearb.h:659
GLuint GLsizei const GLuint const GLintptr * offsets
Definition glcorearb.h:2595
GLuint GLuint end
Definition glcorearb.h:469
GLenum array
Definition glcorearb.h:4274
GLuint index
Definition glcorearb.h:781
GLdouble f
Definition glcorearb.h:310
GLboolean GLboolean GLboolean b
Definition glcorearb.h:1233
GLsizei const GLfloat * value
Definition glcorearb.h:819
GLenum target
Definition glcorearb.h:1641
GLint GLint GLsizei GLint GLenum GLenum type
Definition glcorearb.h:275
GLboolean * data
Definition glcorearb.h:298
GLintptr offset
Definition glcorearb.h:660
GLuint GLsizei GLsizei * length
Definition glcorearb.h:790
GLuint GLsizei const GLchar * label
Definition glcorearb.h:2519
GLsizei GLenum const void * indices
Definition glcorearb.h:400
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
GLboolean r
Definition glcorearb.h:1233
GLuint start
Definition glcorearb.h:469
GLenum GLenum GLsizei len
Definition glcorearb.h:4232
GLboolean GLboolean GLboolean GLboolean a
Definition glcorearb.h:1233
GLint ref
Definition glcorearb.h:291
std::shared_ptr< gandiva::SelectionVector > Selection
Definition Expressions.h:47
consteval const char * origin_str()
Definition ASoA.h:344
consteval const char * signature()
Definition ASoA.h:356
consteval auto filterForKey()
Filter TableRef array for compatibility with Key table.
Definition ASoA.h:264
consteval const char * label()
Definition ASoA.h:338
consteval header::DataOrigin origin()
Definition ASoA.h:350
std::shared_ptr< arrow::DataType > concreteArrowType(atype::type type)
gandiva::Selection createSelection(std::shared_ptr< arrow::Table > const &table, Filter const &expression)
Function for creating gandiva selection from our internal filter tree.
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
std::decay_t< decltype(select_pack< Condition >(pack<>{}, Pack{}, CondPack{}))> selected_pack_multicondition
Definition Pack.h:181
std::decay_t< decltype(prune_voids_pack(pack<>{}, with_condition_pack< Condition, Types... >{}))> selected_pack
Definition Pack.h:179
decltype(intersected_pack(Ps{}...)) full_intersected_pack_t
Definition Pack.h:283
typename pack_element< I, T >::type pack_element_t
Definition Pack.h:56
consteval size_t has_type_at_v(pack< Ts... >)
Definition Pack.h:228
constexpr std::size_t pack_size(pack< Ts... > const &)
template function to determine number of types in a pack
Definition Pack.h:28
decltype(concatenate_pack_unique(Ps{}...)) concatenated_pack_unique_t
Definition Pack.h:319
std::pair< std::string, std::string > StringPair
std::string strToUpper(std::string &&str)
Definition ASoA.cxx:189
typename pack_element< 0, T >::type pack_head_t
Definition Pack.h:59
std::string cutString(std::string &&str)
Definition ASoA.cxx:180
std::vector< std::vector< int64_t > > ListVector
Descriptor< gSizeDataDescriptionString > DataDescription
Definition DataHeader.h:551
std::array< std::shared_ptr< arrow::Array >, sizeof...(Cs)> getChunks(arrow::Table *table, framework::pack< Cs... >, uint64_t ci)
Definition ASoA.h:2145
ColumnGetterFunction< R, typename T::iterator > getColumnGetterByLabel(const std::string_view &targetColumnLabel)
Definition ASoA.h:2253
std::array< arrow::ChunkedArray *, sizeof...(Cs)> getArrowColumns(arrow::Table *table, framework::pack< Cs... >)
Definition ASoA.h:2139
std::tuple< typename Cs::type... > getRowData(arrow::Table *table, T rowIterator, uint64_t ci=std::numeric_limits< uint64_t >::max(), uint64_t ai=std::numeric_limits< uint64_t >::max(), uint64_t globalIndex=std::numeric_limits< uint64_t >::max())
Definition ASoA.h:2180
C::type getSingleRowData(arrow::Table *table, T &rowIterator, uint64_t ci=std::numeric_limits< uint64_t >::max(), uint64_t ai=std::numeric_limits< uint64_t >::max(), uint64_t globalIndex=std::numeric_limits< uint64_t >::max())
Definition ASoA.h:2151
consteval auto computeOriginals()
Definition ASoA.h:1663
auto createFieldsFromColumns(framework::pack< C... >)
Definition ASoA.h:406
SelectionVector selectionToVector(gandiva::Selection const &sel)
Definition ASoA.cxx:43
constexpr bool is_persistent_v
Definition ASoA.h:188
constexpr bool is_ng_index_equivalent_v
Definition ASoA.h:448
consteval auto remove_if(L l)
Definition ASoA.h:126
constexpr auto join(Ts const &... t)
Definition ASoA.h:3294
auto doSliceBy(T const *table, o2::framework::PresliceBase< C, Policy, OPT > const &container, int value)
Definition ASoA.h:1507
SelectionVector sliceSelection(gsl::span< int64_t const > const &mSelectedRows, int64_t nrows, uint64_t offset)
Definition ASoA.cxx:53
void notBoundTable(const char *tableName)
Definition ASoA.cxx:161
auto doFilteredSliceBy(T const *table, o2::framework::PresliceBase< C, framework::PreslicePolicySorted, OPT > const &container, int value)
Definition ASoA.h:1573
constexpr auto concat(Ts const &... t)
Definition ASoA.h:3338
consteval auto intersectOriginals()
Definition ASoA.h:161
consteval auto getColumns()
Definition ASoA.h:1635
std::vector< int64_t > SelectionVector
Definition ASoA.h:411
std::conditional_t< is_binding_compatible_v< T, typename B::binding_t >(), std::true_type, std::false_type > is_binding_compatible
Definition ASoA.h:1289
consteval auto mergeOriginals()
Definition ASoA.h:144
constexpr bool is_soa_filtered_v
Definition ASoA.h:1488
typename std::conditional_t< is_index_column< C >, std::true_type, std::false_type > is_external_index_t
Definition ASoA.h:203
void missingFilterDeclaration(int hash, int ai)
Definition ASoA.cxx:28
auto doSliceByCachedUnsorted(T const *table, framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache)
Definition ASoA.h:1605
auto doSliceByCached(T const *table, framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache)
Definition ASoA.h:1586
void accessingInvalidIndexFor(const char *getter)
Definition ASoA.cxx:20
auto select(T const &t, framework::expressions::Filter const &f)
Definition ASoA.h:1621
consteval auto base_iter(framework::pack< C... > &&) -> TableIterator< D, O, IP, C... >
Definition ASoA.h:1629
constexpr bool is_index_equivalent_v
Definition ASoA.h:445
constexpr bool is_soa_join_v
Definition ASoA.h:3303
void dereferenceWithWrongType(const char *getter, const char *target)
Definition ASoA.cxx:24
std::conditional_t< is_indexing_column< T >, std::true_type, std::false_type > is_indexing_t
Definition ASoA.h:824
auto doSliceByHelper(T const *table, gsl::span< const int64_t > const &selection)
Definition ASoA.h:1523
consteval bool is_binding_compatible_v()
Definition ASoA.h:1283
auto prepareFilteredSlice(T const *table, std::shared_ptr< arrow::Table > slice, uint64_t offset)
Definition ASoA.h:1558
void emptyColumnLabel()
Definition ASoA.cxx:38
typename unwrap< T >::type unwrap_t
Definition ASoA.h:480
void getterNotFound(const char *targetColumnLabel)
Definition ASoA.cxx:33
auto doFilteredSliceByCached(T const *table, framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache)
Definition ASoA.h:1596
void missingOptionalPreslice(const char *label, const char *key)
Definition ASoA.cxx:171
consteval bool is_compatible()
Definition ASoA.h:1270
arrow::ChunkedArray * getIndexFromLabel(arrow::Table *table, std::string_view label)
Definition ASoA.cxx:140
consteval auto merge()
Helpers to manipulate TableRef arrays.
Definition ASoA.h:103
consteval auto merge_if(L l)
Definition ASoA.h:114
std::conditional_t< is_persistent_column< C >, std::true_type, std::false_type > is_persistent_column_t
Definition ASoA.h:191
typename arrow_array_for< T >::type arrow_array_for_t
Definition ArrowTypes.h:112
void notFoundColumn(const char *label, const char *key)
Definition ASoA.cxx:166
std::conditional_t< is_dynamic_column< T >, std::true_type, std::false_type > is_dynamic_t
Definition ASoA.h:818
typename std::conditional_t< is_self_index_column< C >, std::true_type, std::false_type > is_self_index_t
Definition ASoA.h:206
Defining DataPointCompositeObject explicitly as copiable.
FIXME: do not use data model tables.
Definition list.h:40
static constexpr uint32_t hash
Definition ASoA.h:258
static constexpr char const *const str
Definition ASoA.h:259
Base type for table metadata.
Definition ASoA.h:213
static consteval int getIndexPosToKey()
Definition ASoA.h:232
static consteval int getIndexPosToKey_impl()
Definition ASoA.h:238
framework::selected_pack< soa::is_self_index_t, Cs... > internal_index_columns_t
Definition ASoA.h:217
framework::selected_pack< soa::is_persistent_column_t, Cs... > persistent_columns_t
Definition ASoA.h:215
framework::selected_pack< soa::is_external_index_t, Cs... > external_index_columns_t
Definition ASoA.h:216
static consteval std::array< bool, sizeof...(PCs)> getMap(framework::pack< PCs... >)
Definition ASoA.h:220
SliceInfoPtr getCacheFor(StringPair const &bindingKey) const
SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const &bindingKey) const
std::shared_ptr< arrow::Table > getSliceFor(int value, std::shared_ptr< arrow::Table > const &input, uint64_t &offset) const
Definition ASoA.h:1435
static constexpr bool optional
Definition ASoA.h:1425
PresliceBase(expressions::BindingNode index_)
Definition ASoA.h:1430
gsl::span< const int64_t > getSliceFor(int value) const
Definition ASoA.h:1445
const std::string binding
Definition ASoA.h:1428
StringPair const & getBindingKey() const
Definition ASoA.cxx:200
const std::string binding
Definition ASoA.h:1402
SliceInfoUnsortedPtr sliceInfo
Definition ASoA.h:1419
gsl::span< const int64_t > getSliceFor(int value) const
Definition ASoA.cxx:223
void updateSliceInfo(SliceInfoUnsortedPtr &&si)
Definition ASoA.cxx:210
void updateSliceInfo(SliceInfoPtr &&si)
Definition ASoA.cxx:205
std::shared_ptr< arrow::Table > getSliceFor(int value, std::shared_ptr< arrow::Table > const &input, uint64_t &offset) const
Definition ASoA.cxx:215
ArrowTableSlicingCache * ptr
Definition SliceCache.h:22
std::pair< int64_t, int64_t > getSliceFor(int value) const
An expression tree node corresponding to a column binding.
A struct, containing the root of the expression tree.
From https://en.cppreference.com/w/cpp/utility/variant/visit.
static std::shared_ptr< arrow::Table > joinTables(std::vector< std::shared_ptr< arrow::Table > > &&tables)
Definition ASoA.cxx:67
static std::shared_ptr< arrow::Table > concatTables(std::vector< std::shared_ptr< arrow::Table > > &&tables)
Definition ASoA.cxx:100
Type-checking index column binding.
Definition ASoA.h:382
std::span< TableRef const > refs
Definition ASoA.h:385
size_t hash
Definition ASoA.h:384
void const * ptr
Definition ASoA.h:383
void bind(T const *table)
Definition ASoA.h:388
T const * get() const
Definition ASoA.h:396
static constexpr bool chunked
Definition ASoA.h:454
arrow::ChunkedArray * second
Definition ASoA.h:1031
Column(ColumnIterator< T > const &it)
Definition ASoA.h:656
Column()=default
static constexpr const char *const & columnLabel()
Definition ASoA.h:669
ColumnIterator< T > const & getIterator() const
Definition ASoA.h:670
Column & operator=(Column const &)=default
INHERIT inherited_t
Definition ASoA.h:655
Column(Column &&)=default
static auto asArrowField()
Definition ASoA.h:675
Column & operator=(Column &&)=default
Column(Column const &)=default
ColumnIterator< T > mColumnIterator
Definition ASoA.h:682
table_t::template iterator_template< DefaultIndexPolicy, self_t, Ts... > iterator
Definition ASoA.h:3329
Concat(Ts const &... t, uint64_t offset=0)
Definition ASoA.h:3314
typename table_t::persistent_columns_t persistent_columns_t
Definition ASoA.h:3327
typename table_t::columns_t columns_t
Definition ASoA.h:3326
iterator const_iterator
Definition ASoA.h:3330
const_iterator unfiltered_const_iterator
Definition ASoA.h:3332
iterator unfiltered_iterator
Definition ASoA.h:3331
table_t::template iterator_template< FilteredIndexPolicy, self_t, Ts... > filtered_iterator
Definition ASoA.h:3333
Concat(std::vector< std::shared_ptr< arrow::Table > > &&tables, uint64_t offset=0)
Definition ASoA.h:3309
filtered_iterator filtered_const_iterator
Definition ASoA.h:3334
DefaultIndexPolicy(int64_t nRows, uint64_t offset)
Definition ASoA.h:953
friend bool operator==(DefaultIndexPolicy const &lh, DefaultIndexPolicy const &rh)
Definition ASoA.h:999
bool operator==(RowViewSentinel const &sentinel) const
Definition ASoA.h:1004
DefaultIndexPolicy(FilteredIndexPolicy const &other)
Definition ASoA.h:959
std::tuple< uint64_t const * > getOffsets() const
Definition ASoA.h:980
DefaultIndexPolicy & operator=(DefaultIndexPolicy &&)=default
void setCursor(int64_t i)
Definition ASoA.h:985
void limitRange(int64_t start, int64_t end)
Definition ASoA.h:965
DefaultIndexPolicy(DefaultIndexPolicy &&)=default
DefaultIndexPolicy(DefaultIndexPolicy const &)=default
DefaultIndexPolicy & operator=(DefaultIndexPolicy const &)=default
std::tuple< int64_t const *, int64_t const * > getIndices() const
Definition ASoA.h:974
DefaultIndexPolicy()=default
Needed to be able to copy the policy.
void moveByIndex(int64_t i)
Definition ASoA.h:989
static constexpr const char *const & columnLabel()
Definition ASoA.h:691
INHERIT inherited_t
Definition ASoA.h:689
void resetSelection(gsl::span< int64_t const > selection)
Definition ASoA.h:852
FilteredIndexPolicy & operator=(FilteredIndexPolicy &&)=default
std::tuple< int64_t const *, int64_t const * > getIndices() const
Definition ASoA.h:866
FilteredIndexPolicy & operator=(FilteredIndexPolicy const &)=default
auto getSelectionRow() const
Definition ASoA.h:916
friend bool operator==(FilteredIndexPolicy const &lh, FilteredIndexPolicy const &rh)
Definition ASoA.h:897
void setCursor(int64_t i)
Definition ASoA.h:885
FilteredIndexPolicy(FilteredIndexPolicy const &)=default
auto raw_size() const
Definition ASoA.h:926
bool operator==(RowViewSentinel const &sentinel) const
Definition ASoA.h:902
std::tuple< uint64_t const * > getOffsets() const
Definition ASoA.h:872
void limitRange(int64_t start, int64_t end)
Definition ASoA.h:877
FilteredIndexPolicy(gsl::span< int64_t const > selection, int64_t rows, uint64_t offset=0)
Definition ASoA.h:843
FilteredIndexPolicy(FilteredIndexPolicy &&)=default
void moveByIndex(int64_t i)
Definition ASoA.h:891
static constexpr bool chunked
Definition ASoA.h:460
static constexpr const char *const & columnLabel()
Definition ASoA.h:698
INHERIT inherited_t
Definition ASoA.h:696
uint64_t mOffset
Offset within a larger table.
Definition ASoA.h:830
int64_t mRowIndex
Position inside the current table.
Definition ASoA.h:828
IndexTable(std::vector< std::shared_ptr< arrow::Table > > tables, uint64_t offset=0)
Definition ASoA.h:3965
IndexTable(std::shared_ptr< arrow::Table > table, uint64_t offset=0)
Definition ASoA.h:3960
typename base_t::template iterator_template_o< DefaultIndexPolicy, self_t > iterator
Definition ASoA.h:3975
filtered_iterator const_filtered_iterator
Definition ASoA.h:3978
IndexTable(IndexTable &&)=default
IndexTable & operator=(IndexTable const &)=default
iterator const_iterator
Definition ASoA.h:3976
IndexTable & operator=(IndexTable &&)=default
typename H::binding_t first_t
Definition ASoA.h:3957
typename base_t::template iterator_template_o< FilteredIndexPolicy, self_t > filtered_iterator
Definition ASoA.h:3977
IndexTable(IndexTable const &)=default
int64_t type
Definition ASoA.h:795
Index(Index const &)=default
void setIndices(std::tuple< int64_t const *, int64_t const * > indices)
Definition ASoA.h:784
Index & operator=(Index &&)=default
int64_t index() const
Definition ASoA.h:757
Index()=default
Index(arrow::ChunkedArray const *)
Definition ASoA.h:743
int64_t filteredIndex() const
Definition ASoA.h:762
constexpr int64_t rangeEnd()
Definition ASoA.h:752
constexpr int64_t rangeStart()
Definition ASoA.h:747
Index(Index &&)=default
Index & operator=(Index const &)=default
int64_t index() const
Definition ASoA.h:773
int64_t globalIndex() const
Definition ASoA.h:767
std::tuple< int64_t const *, int64_t const * > rowIndices
Definition ASoA.h:797
int64_t offsets() const
Definition ASoA.h:779
void setOffsets(std::tuple< uint64_t const * > offsets)
Definition ASoA.h:789
static constexpr const char * mLabel
Definition ASoA.h:794
std::tuple< uint64_t const * > rowOffsets
Definition ASoA.h:800
iterator begin()
Definition ASoA.h:3235
iterator unfiltered_iterator
Definition ASoA.h:3230
auto sliceBy(o2::framework::PresliceBase< T1, Policy, OPT > const &container, int value) const
Definition ASoA.h:3256
auto rawSlice(uint64_t start, uint64_t end) const
Definition ASoA.h:3273
auto sliceByCachedUnsorted(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3250
JoinFull(std::vector< std::shared_ptr< arrow::Table > > &&tables, uint64_t offset=0)
Definition ASoA.h:3215
const_iterator unfiltered_const_iterator
Definition ASoA.h:3231
filtered_iterator filtered_const_iterator
Definition ASoA.h:3233
static consteval bool contains()
Definition ASoA.h:3284
iterator iteratorAt(uint64_t i) const
Definition ASoA.h:3268
typename table_t::columns_t columns_t
Definition ASoA.h:3226
table_t::template iterator_template< DefaultIndexPolicy, self_t, Ts... > iterator
Definition ASoA.h:3228
table_t::template iterator_template< FilteredIndexPolicy, self_t, Ts... > filtered_iterator
Definition ASoA.h:3232
static constexpr const auto originals
Definition ASoA.h:3225
JoinFull< D, Ts... > self_t
Definition ASoA.h:3223
const_iterator begin() const
Definition ASoA.h:3240
typename table_t::persistent_columns_t persistent_columns_t
Definition ASoA.h:3227
iterator const_iterator
Definition ASoA.h:3229
iterator rawIteratorAt(uint64_t i) const
Definition ASoA.h:3261
Table< o2::aod::Hash<"JOIN"_h >, D, o2::aod::Hash<"JOIN"_h >, Ts... > base
Definition ASoA.h:3208
JoinFull(std::shared_ptr< arrow::Table > &&table, uint64_t offset=0)
Definition ASoA.h:3210
auto emptySlice() const
Definition ASoA.h:3278
auto sliceByCached(framework::expressions::BindingNode const &node, int value, o2::framework::SliceCache &cache) const
Definition ASoA.h:3245
static constexpr const char *const & columnLabel()
Definition ASoA.h:705
INHERIT inherited_t
Definition ASoA.h:703
constexpr auto mark()
Definition ASoA.h:722
Marker & operator=(Marker const &)=default
size_t type
Definition ASoA.h:710
static constexpr auto value
Definition ASoA.h:712
static constexpr const char * mLabel
Definition ASoA.h:727
Marker(arrow::ChunkedArray const *)
Definition ASoA.h:721
Marker()=default
Marker(Marker const &)=default
Marker & operator=(Marker &&)=default
Marker(Marker &&)=default
int64_t const index
Definition ASoA.h:834
SmallGroupsBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, SelectionVector &&selection, uint64_t offset=0)
Definition ASoA.h:3987
SmallGroupsBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, gsl::span< int64_t const > const &selection, uint64_t offset=0)
Definition ASoA.h:3990
SmallGroupsBase(std::vector< std::shared_ptr< arrow::Table > > &&tables, gandiva::Selection const &selection, uint64_t offset=0)
Definition ASoA.h:3984
framework::selected_pack< soa::is_persistent_column_t, C... > persistent_columns_t
Definition ASoA.h:1048
void doSetCurrentIndexRaw(framework::pack< Cs... > p, std::vector< o2::soa::Binding > &&ptrs)
Definition ASoA.h:1171
void bindInternalIndices(I const *table)
Definition ASoA.h:1190
TableIterator(TableIterator< D, O, FilteredIndexPolicy, C... > const &other)
Definition ASoA.h:1089
TableIterator(self_t const &other)
Definition ASoA.h:1074
TableIterator operator-(int64_t dec) const
Definition ASoA.h:1131
TableIterator(arrow::ChunkedArray *columnData[sizeof...(C)], IP &&policy)
Definition ASoA.h:1060
TableIterator & operator=(TableIterator other)
Definition ASoA.h:1081
TableIterator & operator++()
Definition ASoA.h:1097
void doSetCurrentInternal(framework::pack< Cs... >, I const *ptr)
Definition ASoA.h:1177
auto getIndexBindingsImpl(framework::pack< Cs... >) const
Definition ASoA.h:1154
TableIterator operator--(int)
Definition ASoA.h:1116
void bindExternalIndicesRaw(std::vector< o2::soa::Binding > &&ptrs)
Definition ASoA.h:1184
TableIterator(arrow::ChunkedArray *columnData[sizeof...(C)], IP &&policy)
Definition ASoA.h:1053
decltype([]< typename... Cs >(framework::pack< Cs... >) -> framework::pack< typename Cs::binding_t... > {}(external_index_columns_t{})) bindings_pack_t
Definition ASoA.h:1051
void bindExternalIndices(TA *... current)
Definition ASoA.h:1165
auto getCurrent() const
Definition ASoA.h:1148
TableIterator & operator--()
Definition ASoA.h:1110
framework::selected_pack< soa::is_external_index_t, C... > external_index_columns_t
Definition ASoA.h:1049
TableIterator const & operator*() const
Definition ASoA.h:1136
TableIterator operator++(int)
Definition ASoA.h:1103
framework::selected_pack< soa::is_self_index_t, C... > internal_index_columns_t
Definition ASoA.h:1050
auto getIndexBindings() const
Definition ASoA.h:1159
void doSetCurrentIndex(framework::pack< CL... >, TA *current)
Definition ASoA.h:1142
TableIterator operator+(int64_t inc) const
Allow incrementing by more than one the iterator.
Definition ASoA.h:1124
Generic identifier for a table type.
Definition ASoA.h:57
constexpr TableRef & operator=(TableRef const &)=default
consteval TableRef()
Definition ASoA.h:58
uint32_t label_hash
Definition ASoA.h:72
constexpr bool descriptionCompatible(uint32_t _desc_hash) const noexcept
Definition ASoA.h:90
constexpr bool operator==(TableRef const &other) const noexcept
Definition ASoA.h:77
constexpr TableRef(TableRef &&)=default
uint32_t version
Definition ASoA.h:75
constexpr TableRef(TableRef const &)=default
consteval TableRef(uint32_t _label, uint32_t _desc, uint32_t _origin, uint32_t _version)
Definition ASoA.h:65
constexpr bool descriptionCompatible(TableRef const &other) const noexcept
Definition ASoA.h:85
uint32_t desc_hash
Definition ASoA.h:73
uint32_t origin_hash
Definition ASoA.h:74
constexpr TableRef & operator=(TableRef &&)=default
TableIteratorBase const & operator*() const
Definition ASoA.h:1874
TableIteratorBase(TableIteratorBase< IP, P, T... > const &other)
Definition ASoA.h:1782
typename Parent::columns_t columns_t
Definition ASoA.h:1729
TableIteratorBase(TableIteratorBase< IP, P, O1, Os... > const &other)
Definition ASoA.h:1768
typename Parent::external_index_columns_t external_index_columns_t
Definition ASoA.h:1730
TableIteratorBase operator-(int64_t dec) const
Definition ASoA.h:1869
void matchTo(TableIteratorBase< IP, P, T... > const &other)
Definition ASoA.h:1806
void matchTo(TableIteratorBase< IP, P, Os... > const &other)
Definition ASoA.h:1812
TableIteratorBase(TableIteratorBase< FilteredIndexPolicy, P, T... > other)
Definition ASoA.h:1794
std::array< B, sizeof...(CCs)> getValues() const
Definition ASoA.h:1851
static constexpr auto originals
Definition ASoA.h:1733
TableIteratorBase(TableIteratorBase< IP, P, T... > &&other) noexcept
Definition ASoA.h:1788
decltype([]< typename... C >(framework::pack< C... >) -> framework::pack< typename C::binding_t... > {}(external_index_columns_t{})) bindings_pack_t
Definition ASoA.h:1731
TableIteratorBase & operator=(TableIteratorBase< IP, P, Os... > other)
Definition ASoA.h:1745
TableIteratorBase(TableIteratorBase< IP, P, O1, Os... > &&other) noexcept
Definition ASoA.h:1775
TableIteratorBase & operator=(RowViewSentinel const &other)
Definition ASoA.h:1800
TableIteratorBase(arrow::ChunkedArray *columnData[framework::pack_size(columns_t{})], IP &&policy)
Definition ASoA.h:1739
TableIteratorBase & operator=(TableIteratorBase< IP, P, T... > other)
Definition ASoA.h:1753
TableIteratorBase operator+(int64_t inc) const
Allow incrementing by more than one the iterator.
Definition ASoA.h:1862
TableIteratorBase & operator=(TableIteratorBase< FilteredIndexPolicy, P, T... > other)
Definition ASoA.h:1760
unwrapper
Definition ASoA.h:465
VectorOfTObjectPtrs other
std::vector< ReadoutWindowData > rows
const std::string str