make it pass tests

aalkin · aalkin · commit bd7f342e21b4 · 2026-07-13T09:50:08.000+02:00
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
@@ -502,13 +502,13 @@ class ColumnIterator : ChunkingPolicy
     : mColumn{column},
       mCurrent{nullptr},
       mCurrentPos{nullptr},
+      mGlobalOffset{nullptr},
       mLast{nullptr},
       mFirstIndex{0},
-      mCurrentChunk{0},
-      mOffset{0}
+      mCurrentChunk{0}
   {
     auto array = getCurrentArray();
-    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR);
+    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data());
     mLast = mCurrent + array->length();
   }
 
@@ -524,21 +524,19 @@ class ColumnIterator : ChunkingPolicy
   {
     auto previousArray = getCurrentArray();
     mFirstIndex += previousArray->length();
-
     mCurrentChunk++;
     auto array = getCurrentArray();
-    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
+    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);
     mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
   }
 
   void prevChunk() const
   {
     auto previousArray = getCurrentArray();
     mFirstIndex -= previousArray->length();
-
     mCurrentChunk--;
     auto array = getCurrentArray();
-    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
+    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);
     mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
   }
 
@@ -561,24 +559,24 @@ class ColumnIterator : ChunkingPolicy
     mCurrentChunk = mColumn->num_chunks() - 1;
     auto array = getCurrentArray();
     mFirstIndex = mColumn->length() - array->length();
-    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);
+    mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);
     mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
   }
 
   auto operator*() const
     requires std::same_as<bool, std::decay_t<T>>
   {
     checkSkipChunk();
-    return (*(mCurrent - (mOffset >> SCALE_FACTOR) + ((*mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;
+    return (*(mCurrent + ((*mCurrentPos + *mGlobalOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + *mGlobalOffset) & ((1 << SCALE_FACTOR) - 1)))) != 0;
   }
 
   auto operator*() const
     requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
     checkSkipChunk();
     auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));
-    auto offset = list->value_offset(*mCurrentPos - mFirstIndex);
-    auto length = list->value_length(*mCurrentPos - mFirstIndex);
+    auto offset = list->value_offset(*mCurrentPos + *mGlobalOffset - mFirstIndex);
+    auto length = list->value_length(*mCurrentPos + *mGlobalOffset - mFirstIndex);
     return gsl::span<unwrap_t<T> const>{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
   }
 
@@ -587,14 +585,14 @@ class ColumnIterator : ChunkingPolicy
   {
     checkSkipChunk();
     auto array = std::static_pointer_cast<arrow::BinaryViewArray>(mColumn->chunk(mCurrentChunk));
-    return array->GetView(*mCurrentPos - mFirstIndex);
+    return array->GetView(*mCurrentPos + *mGlobalOffset - mFirstIndex);
   }
 
   decltype(auto) operator*() const
     requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray> && !std::same_as<arrow_array_for_t<T>, arrow::BinaryViewArray>)
   {
     checkSkipChunk();
-    return *(mCurrent + (*mCurrentPos >> SCALE_FACTOR));
+    return *(mCurrent + ((*mCurrentPos + *mGlobalOffset) >> SCALE_FACTOR));
   }
 
   // Move to the chunk which containts element pos
@@ -606,26 +604,26 @@ class ColumnIterator : ChunkingPolicy
 
   mutable unwrap_t<T> const* mCurrent;
   int64_t const* mCurrentPos;
+  uint64_t const* mGlobalOffset;
   mutable unwrap_t<T> const* mLast;
   arrow::ChunkedArray const* mColumn;
   mutable int mFirstIndex;
   mutable int mCurrentChunk;
-  mutable int mOffset;
 
  private:
   void checkSkipChunk() const
     requires((ChunkingPolicy::chunked == true) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
     auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));
-    if (O2_BUILTIN_UNLIKELY(*mCurrentPos - mFirstIndex >= list->length())) {
+    if (O2_BUILTIN_UNLIKELY(*mCurrentPos + *mGlobalOffset - mFirstIndex >= list->length())) {
       nextChunk();
     }
   }
 
   void checkSkipChunk() const
     requires((ChunkingPolicy::chunked == true) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
-    if (O2_BUILTIN_UNLIKELY(((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) >= mLast))) {
+    if (O2_BUILTIN_UNLIKELY(((mCurrent + ((*mCurrentPos + *mGlobalOffset) >> SCALE_FACTOR)) >= mLast))) {
       nextChunk();
     }
   }
@@ -639,7 +637,6 @@ class ColumnIterator : ChunkingPolicy
     requires(std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray>)
   {
     std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
-    mOffset = chunkToUse->offset();
     chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
     return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);
   }
@@ -648,17 +645,14 @@ class ColumnIterator : ChunkingPolicy
     requires(std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
     std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
-    mOffset = chunkToUse->offset();
     chunkToUse = std::dynamic_pointer_cast<arrow::ListArray>(chunkToUse)->values();
-    mOffset = chunkToUse->offset();
     return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);
   }
 
   auto getCurrentArray() const
     requires(!std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray> && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
     std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
-    mOffset = chunkToUse->offset();
     return std::static_pointer_cast<arrow_array_for_t<T>>(chunkToUse);
   }
 };
@@ -1212,7 +1206,7 @@ struct TableIterator : IP, C... {
   {
     using namespace o2::soa;
     auto f = framework::overloaded{
-      [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
+      [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; T::mColumnIterator.mGlobalOffset = &this->mOffset; },
       [this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },
       [this]<typename T>(T*) -> void {},
     };
@@ -3468,11 +3462,6 @@ struct Concat : Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::ao
   {
   }
 
-  Concat(std::vector<std::shared_ptr<arrow::Table>>&& tables)
-    : Concat{ArrowHelpers::concatTables(std::move(tables))}
-  {
-  }
-
   Concat(Ts const&... t)
     : Concat{ArrowHelpers::concatTables({t.asArrowTableRef()...})}
   {
@@ -3729,19 +3718,31 @@ class FilteredBase : public T
     }
   }
 
-  inline void adoptSelection(gandiva::Selection const& selection)
+  template <typename S>
+  inline void adoptSelection(S)
+  {
+  }
+
+  template <typename S>
+    requires(std::same_as<std::decay_t<S>, gandiva::Selection>)
+  inline void adoptSelection(S selection)
   {
     mSelectedRows = getSpan(selection);
     mCached = false;
   }
 
-  inline void adoptSelection(SelectionVector&& selection)
+  template <typename S>
+    requires(std::same_as<std::decay_t<S>, SelectionVector>)
+  inline void adoptSelection(S selection)
   {
     mSelectedRowsCache = std::move(selection);
+    mSelectedRows = std::span{mSelectedRowsCache};
     mCached = true;
   }
 
-  inline void adoptSelection(std::span<int64_t const> const& selection)
+  template <typename S>
+    requires(std::same_as<std::decay_t<S>, std::span<int64_t const>>)
+  inline void adoptSelection(S selection)
   {
     mSelectedRows = selection;
     mCached = false;
@@ -3778,7 +3779,7 @@ class Filtered : public FilteredBase<T>
   }
 
   Filtered(std::vector<ArrowTableRef>&& tables, is_a_selection auto selection)
-    : FilteredBase<T>{std::move(tables), selection} {}
+    : FilteredBase<T>{std::move(tables), std::forward<decltype(selection)>(selection)} {}
 
   Filtered<T> operator+(is_a_selection auto selection)
   {
@@ -3908,7 +3909,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
   }
 
   Filtered(std::vector<Filtered<T>>&& tables, is_a_selection auto selection)
-    : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), selection)
+    : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), std::forward<decltype(selection)>(selection))
   {
     for (auto& table : tables) {
       *this *= table;
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
@@ -177,42 +177,36 @@ o2::soa::ArrowTableRef ArrowHelpers::concatTables(std::vector<o2::soa::ArrowTabl
     return tables.front();
   }
   std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
-  std::vector<std::shared_ptr<arrow::Field>> resultFields = tables[0]->schema()->fields();
+  std::vector<std::shared_ptr<arrow::Field>> resultFields = tables.front()->schema()->fields();
   auto compareFields = [](std::shared_ptr<arrow::Field> const& f1, std::shared_ptr<arrow::Field> const& f2) {
     // Let's do this with stable sorting.
     return (!f1->Equals(f2)) && (f1->name() < f2->name());
   };
-  std::ranges::for_each(tables.begin() + 1, tables.end(), [&resultFields, &compareFields](auto const& ref) mutable {
-    std::vector<std::shared_ptr<arrow::Field>> const& fields = ref->fields();
+
+  for (auto i = 1; i < tables.size(); ++i) {
+    auto const& fields = tables[i]->fields();
     std::vector<std::shared_ptr<arrow::Field>> intersection;
     std::ranges::set_intersection(resultFields, fields, std::back_inserter(intersection), compareFields);
     resultFields.swap(intersection);
-  });
+  }
 
-  std::ranges::transform(resultFields, std::back_inserter(columns), [&tables](auto const& field){
+  for (auto const& field : resultFields) {
     arrow::ArrayVector chunks;
-    std::ranges::for_each(tables, [&field, &chunks](auto const& table){
+    for (auto const& table : tables) {
       auto ci = table->schema()->GetFieldIndex(field->name());
       if (ci == -1) {
-        throw std::runtime_error("Unable to find field " + field->name());
+        throw framework::runtime_error_f("Unable to find field {}", field->name().c_str());
       }
       auto column = table->column(ci);
       auto otherChunks = column->chunks();
       chunks.insert(chunks.end(), otherChunks.begin(), otherChunks.end());
-    });
-    return std::make_shared<arrow::ChunkedArray>(chunks);
-  });
+    }
+    columns.push_back(std::make_shared<arrow::ChunkedArray>(chunks));
+  }
 
   return {arrow::Table::Make(std::make_shared<arrow::Schema>(resultFields), columns)};
 }
 
-o2::soa::ArrowTableRef ArrowHelpers::concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables)
-{
-  std::vector<ArrowTableRef> refs;
-  std::ranges::transform(tables, std::back_inserter(refs),[](auto const& table){ return ArrowTableRef{table}; });
-  return concatTables(std::move(refs));
-}
-
 // ASCII-only lowercase. Column labels are plain identifiers, so we deliberately
 // avoid the locale-aware std::tolower: it goes through the C locale facet on
 // every character and dominated getIndexFromLabel in profiles.
diff --git a/Framework/Core/test/test_ASoA.cxx b/Framework/Core/test/test_ASoA.cxx
@@ -106,7 +106,9 @@ TEST_CASE("TestTableIteration")
 
   auto i = ColumnIterator<int32_t>(table->column(0).get());
   int64_t pos = 0;
+  uint64_t offset = 0;
   i.mCurrentPos = &pos;
+  i.mGlobalOffset = &offset;
   REQUIRE(*i == 0);
   pos++;
   REQUIRE(*i == 0);
@@ -383,7 +385,7 @@ TEST_CASE("TestConcatTables")
   static_assert(std::same_as<NestedJoinTest::columns_t, o2::framework::pack<o2::soa::Index<>, o2::aod::test::Y, o2::aod::test::X, o2::aod::test::Z>>, "Bad nested join");
 
   static_assert(std::same_as<ConcatTest::columns_t, o2::framework::pack<o2::soa::Index<>, o2::aod::test::X>>, "Bad intersection of columns");
-  ConcatTest tests{tableA, tableB};
+  ConcatTest tests{{tableA, tableB}};
   REQUIRE(16 == tests.size());
   for (auto& test : tests) {
     REQUIRE(test.index() == test.x());
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
@@ -195,8 +195,9 @@ TEST_CASE("GroupSlicerSeveralAssociated")
                                  {soa::getLabelFromType<aod::TrksY>(), soa::getMatcherFromTypeForKey<aod::TrksY>(key), key},
                                  {soa::getLabelFromType<aod::TrksZ>(), soa::getMatcherFromTypeForKey<aod::TrksZ>(key), key}});
   auto s = slices.updateCacheEntry(0, {trkTableX});
-  s = slices.updateCacheEntry(1, {trkTableY});
-  s = slices.updateCacheEntry(2, {trkTableZ});
+  s &= slices.updateCacheEntry(1, {trkTableY});
+  s &= slices.updateCacheEntry(2, {trkTableZ});
+  REQUIRE(s.ok());
   o2::framework::GroupSlicer g(e, tt, slices);
 
   auto count = 0;
@@ -631,9 +632,9 @@ TEST_CASE("EmptySliceables")
 TEST_CASE("ArrowDirectSlicing")
 {
   int counts[] = {5, 5, 5, 4, 1};
-  int offsets[] = {0, 5, 10, 15, 19, 20};
+  int const offsets[] = {0, 5, 10, 15, 19, 20};
   int ids[] = {0, 1, 2, 3, 4};
-  int sizes[] = {4, 1, 12, 5, 2};
+  int const sizes[] = {4, 1, 12, 5, 2};
 
   using BigE = soa::Join<aod::Events, aod::EventExtra>;
 
@@ -683,34 +684,25 @@ TEST_CASE("ArrowDirectSlicing")
     REQUIRE(slices_vec[i]->length() == counts[i]);
   }
 
-  std::vector<arrow::Datum> slices;
-  std::vector<uint64_t> offsts;
   auto bk = Entry(soa::getLabelFromType<aod::Events>(), soa::getMatcherFromTypeForKey<aod::Events>("fID"), "fID");
   ArrowTableSlicingCache cache({bk});
   auto s = cache.updateCacheEntry(0, {evtTable});
+  REQUIRE(s.ok());
   auto lcache = cache.getCacheFor(bk);
   for (auto i = 0u; i < 5; ++i) {
-    auto [offset, count] = lcache.getSliceFor(i);
-    auto tbl = b_e.asArrowTableRef().slice({static_cast<uint64_t>(offset), count});
-    auto ca = tbl->GetColumnByName("fArr");
-    auto cb = tbl->GetColumnByName("fBoo");
-    auto cv = tbl->GetColumnByName("fLst");
-    REQUIRE(ca->length() == counts[i]);
-    REQUIRE(cb->length() == counts[i]);
-    REQUIRE(cv->length() == counts[i]);
-    REQUIRE(ca->Equals(slices_array[i]));
-    REQUIRE(cb->Equals(slices_bool[i]));
-    REQUIRE(cv->Equals(slices_vec[i]));
+    auto [loffset, count] = lcache.getSliceFor(i);
+    auto tbl = b_e.asArrowTableRef().slice({static_cast<uint64_t>(loffset), count});
+    REQUIRE(tbl.range.size == counts[i]);
   }
 
   int j = 0u;
   for (auto i = 0u; i < 5; ++i) {
-    auto [offset, count] = lcache.getSliceFor(i);
-    auto tbl = BigE{{b_e.asArrowTableRef().slice({static_cast<uint64_t>(offset), count})}};
+    auto [loffset, count] = lcache.getSliceFor(i);
+    auto tbl = BigE{{b_e.asArrowTableRef().slice({static_cast<uint64_t>(loffset), count})}};
     REQUIRE(tbl.size() == counts[i]);
     for (auto& row : tbl) {
       REQUIRE(row.id() == ids[i]);
-      REQUIRE(row.boo() == (j % 2 == 0));
+      CHECK(row.boo() == (j % 2 == 0));
       auto rid = row.globalIndex();
       auto arr = row.arr();
       REQUIRE(arr[0] == 0.1f * (float)rid);
@@ -729,7 +721,7 @@ TEST_CASE("ArrowDirectSlicing")
 
 TEST_CASE("TestSlicingException")
 {
-  int offsets[] = {0, 5, 10, 15, 19, 20};
+  int const offsets[] = {0, 5, 10, 15, 19, 20};
   int ids[] = {0, 1, 2, 4, 3};
 
   TableBuilder builderE;

Original file line number	Diff line number	Diff line change
`@@ -502,13 +502,13 @@ class ColumnIterator : ChunkingPolicy`
`502`	`502`	`: mColumn{column},`
`503`	`503`	`mCurrent{nullptr},`
`504`	`504`	`mCurrentPos{nullptr},`
	`505`	`+ mGlobalOffset{nullptr},`
`505`	`506`	`mLast{nullptr},`
`506`	`507`	`mFirstIndex{0},`
`507`		`- mCurrentChunk{0},`
`508`		`- mOffset{0}`
	`508`	`+ mCurrentChunk{0}`
`509`	`509`	`{`
`510`	`510`	`auto array = getCurrentArray();`
`511`		`- mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR);`
	`511`	`+ mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data());`
`512`	`512`	`mLast = mCurrent + array->length();`
`513`	`513`	`}`
`514`	`514`
`@@ -524,21 +524,19 @@ class ColumnIterator : ChunkingPolicy`
`524`	`524`	`{`
`525`	`525`	`auto previousArray = getCurrentArray();`
`526`	`526`	`mFirstIndex += previousArray->length();`
`527`		`-`
`528`	`527`	`mCurrentChunk++;`
`529`	`528`	`auto array = getCurrentArray();`
`530`		`- mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);`
	`529`	`+ mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);`
`531`	`530`	`mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);`
`532`	`531`	`}`
`533`	`532`
`534`	`533`	`void prevChunk() const`
`535`	`534`	`{`
`536`	`535`	`auto previousArray = getCurrentArray();`
`537`	`536`	`mFirstIndex -= previousArray->length();`
`538`		`-`
`539`	`537`	`mCurrentChunk--;`
`540`	`538`	`auto array = getCurrentArray();`
`541`		`- mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);`
	`539`	`+ mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);`
`542`	`540`	`mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);`
`543`	`541`	`}`
`544`	`542`
`@@ -561,24 +559,24 @@ class ColumnIterator : ChunkingPolicy`
`561`	`559`	`mCurrentChunk = mColumn->num_chunks() - 1;`
`562`	`560`	`auto array = getCurrentArray();`
`563`	`561`	`mFirstIndex = mColumn->length() - array->length();`
`564`		`- mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) + (mOffset >> SCALE_FACTOR) - (mFirstIndex >> SCALE_FACTOR);`
	`562`	`+ mCurrent = reinterpret_cast<unwrap_t<T> const*>(array->values()->data()) - (mFirstIndex >> SCALE_FACTOR);`
`565`	`563`	`mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);`
`566`	`564`	`}`
`567`	`565`
`568`	`566`	`auto operator*() const`
`569`	`567`	`requires std::same_as<bool, std::decay_t<T>>`
`570`	`568`	`{`
`571`	`569`	`checkSkipChunk();`
`572`		`- return ((mCurrent - (mOffset >> SCALE_FACTOR) + ((mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;`
	`570`	`+ return ((mCurrent + ((mCurrentPos + mGlobalOffset) >> SCALE_FACTOR)) & (1 << ((mCurrentPos + *mGlobalOffset) & ((1 << SCALE_FACTOR) - 1)))) != 0;`
`573`	`571`	`}`
`574`	`572`
`575`	`573`	`auto operator*() const`
`576`	`574`	`requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)`
`577`	`575`	`{`
`578`	`576`	`checkSkipChunk();`
`579`	`577`	`auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));`
`580`		`- auto offset = list->value_offset(*mCurrentPos - mFirstIndex);`
`581`		`- auto length = list->value_length(*mCurrentPos - mFirstIndex);`
	`578`	`+ auto offset = list->value_offset(mCurrentPos + mGlobalOffset - mFirstIndex);`
	`579`	`+ auto length = list->value_length(mCurrentPos + mGlobalOffset - mFirstIndex);`
`582`	`580`	`return gsl::span<unwrap_t<T> const>{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};`
`583`	`581`	`}`
`584`	`582`
`@@ -587,14 +585,14 @@ class ColumnIterator : ChunkingPolicy`
`587`	`585`	`{`
`588`	`586`	`checkSkipChunk();`
`589`	`587`	`auto array = std::static_pointer_cast<arrow::BinaryViewArray>(mColumn->chunk(mCurrentChunk));`
`590`		`- return array->GetView(*mCurrentPos - mFirstIndex);`
	`588`	`+ return array->GetView(mCurrentPos + mGlobalOffset - mFirstIndex);`
`591`	`589`	`}`
`592`	`590`
`593`	`591`	`decltype(auto) operator*() const`
`594`	`592`	`requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray> && !std::same_as<arrow_array_for_t<T>, arrow::BinaryViewArray>)`
`595`	`593`	`{`
`596`	`594`	`checkSkipChunk();`
`597`		`- return (mCurrent + (mCurrentPos >> SCALE_FACTOR));`
	`595`	`+ return (mCurrent + ((mCurrentPos + *mGlobalOffset) >> SCALE_FACTOR));`
`598`	`596`	`}`
`599`	`597`
`600`	`598`	`// Move to the chunk which containts element pos`
`@@ -606,26 +604,26 @@ class ColumnIterator : ChunkingPolicy`
`606`	`604`
`607`	`605`	`mutable unwrap_t<T> const* mCurrent;`
`608`	`606`	`int64_t const* mCurrentPos;`
	`607`	`+ uint64_t const* mGlobalOffset;`
`609`	`608`	`mutable unwrap_t<T> const* mLast;`
`610`	`609`	`arrow::ChunkedArray const* mColumn;`
`611`	`610`	`mutable int mFirstIndex;`
`612`	`611`	`mutable int mCurrentChunk;`
`613`		`- mutable int mOffset;`
`614`	`612`
`615`	`613`	`private:`
`616`	`614`	`void checkSkipChunk() const`
`617`	`615`	`requires((ChunkingPolicy::chunked == true) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)`
`618`	`616`	`{`
`619`	`617`	`auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));`
`620`		`- if (O2_BUILTIN_UNLIKELY(*mCurrentPos - mFirstIndex >= list->length())) {`
	`618`	`+ if (O2_BUILTIN_UNLIKELY(mCurrentPos + mGlobalOffset - mFirstIndex >= list->length())) {`
`621`	`619`	`nextChunk();`
`622`	`620`	`}`
`623`	`621`	`}`
`624`	`622`
`625`	`623`	`void checkSkipChunk() const`
`626`	`624`	`requires((ChunkingPolicy::chunked == true) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)`
`627`	`625`	`{`
`628`		`- if (O2_BUILTIN_UNLIKELY(((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) >= mLast))) {`
	`626`	`+ if (O2_BUILTIN_UNLIKELY(((mCurrent + ((mCurrentPos + mGlobalOffset) >> SCALE_FACTOR)) >= mLast))) {`
`629`	`627`	`nextChunk();`
`630`	`628`	`}`
`631`	`629`	`}`
`@@ -639,7 +637,6 @@ class ColumnIterator : ChunkingPolicy`
`639`	`637`	`requires(std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray>)`
`640`	`638`	`{`
`641`	`639`	`std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);`
`642`		`- mOffset = chunkToUse->offset();`
`643`	`640`	`chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();`
`644`	`641`	`return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);`
`645`	`642`	`}`
`@@ -648,17 +645,14 @@ class ColumnIterator : ChunkingPolicy`
`648`	`645`	`requires(std::same_as<arrow_array_for_t<T>, arrow::ListArray>)`
`649`	`646`	`{`
`650`	`647`	`std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);`
`651`		`- mOffset = chunkToUse->offset();`
`652`	`648`	`chunkToUse = std::dynamic_pointer_cast<arrow::ListArray>(chunkToUse)->values();`
`653`		`- mOffset = chunkToUse->offset();`
`654`	`649`	`return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);`
`655`	`650`	`}`
`656`	`651`
`657`	`652`	`auto getCurrentArray() const`
`658`	`653`	`requires(!std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray> && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)`
`659`	`654`	`{`
`660`	`655`	`std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);`
`661`		`- mOffset = chunkToUse->offset();`
`662`	`656`	`return std::static_pointer_cast<arrow_array_for_t<T>>(chunkToUse);`
`663`	`657`	`}`
`664`	`658`	`};`
`@@ -1212,7 +1206,7 @@ struct TableIterator : IP, C... {`
`1212`	`1206`	`{`
`1213`	`1207`	`using namespace o2::soa;`
`1214`	`1208`	`auto f = framework::overloaded{`
`1215`		`- [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },`
	`1209`	`+ [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; T::mColumnIterator.mGlobalOffset = &this->mOffset; },`
`1216`	`1210`	`[this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },`
`1217`	`1211`	`[this]<typename T>(T*) -> void {},`
`1218`	`1212`	`};`
`@@ -3468,11 +3462,6 @@ struct Concat : Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::ao`
`3468`	`3462`	`{`
`3469`	`3463`	`}`
`3470`	`3464`
`3471`		`- Concat(std::vector<std::shared_ptr<arrow::Table>>&& tables)`
`3472`		`- : Concat{ArrowHelpers::concatTables(std::move(tables))}`
`3473`		`- {`
`3474`		`- }`
`3475`		`-`
`3476`	`3465`	`Concat(Ts const&... t)`
`3477`	`3466`	`: Concat{ArrowHelpers::concatTables({t.asArrowTableRef()...})}`
`3478`	`3467`	`{`
`@@ -3729,19 +3718,31 @@ class FilteredBase : public T`
`3729`	`3718`	`}`
`3730`	`3719`	`}`
`3731`	`3720`
`3732`		`- inline void adoptSelection(gandiva::Selection const& selection)`
	`3721`	`+ template <typename S>`
	`3722`	`+ inline void adoptSelection(S)`
	`3723`	`+ {`
	`3724`	`+ }`
	`3725`	`+`
	`3726`	`+ template <typename S>`
	`3727`	`+ requires(std::same_as<std::decay_t<S>, gandiva::Selection>)`
	`3728`	`+ inline void adoptSelection(S selection)`
`3733`	`3729`	`{`
`3734`	`3730`	`mSelectedRows = getSpan(selection);`
`3735`	`3731`	`mCached = false;`
`3736`	`3732`	`}`
`3737`	`3733`
`3738`		`- inline void adoptSelection(SelectionVector&& selection)`
	`3734`	`+ template <typename S>`
	`3735`	`+ requires(std::same_as<std::decay_t<S>, SelectionVector>)`
	`3736`	`+ inline void adoptSelection(S selection)`
`3739`	`3737`	`{`
`3740`	`3738`	`mSelectedRowsCache = std::move(selection);`
	`3739`	`+ mSelectedRows = std::span{mSelectedRowsCache};`
`3741`	`3740`	`mCached = true;`
`3742`	`3741`	`}`
`3743`	`3742`
`3744`		`- inline void adoptSelection(std::span<int64_t const> const& selection)`
	`3743`	`+ template <typename S>`
	`3744`	`+ requires(std::same_as<std::decay_t<S>, std::span<int64_t const>>)`
	`3745`	`+ inline void adoptSelection(S selection)`
`3745`	`3746`	`{`
`3746`	`3747`	`mSelectedRows = selection;`
`3747`	`3748`	`mCached = false;`
`@@ -3778,7 +3779,7 @@ class Filtered : public FilteredBase<T>`
`3778`	`3779`	`}`
`3779`	`3780`
`3780`	`3781`	`Filtered(std::vector<ArrowTableRef>&& tables, is_a_selection auto selection)`
`3781`		`- : FilteredBase<T>{std::move(tables), selection} {}`
	`3782`	`+ : FilteredBase<T>{std::move(tables), std::forward<decltype(selection)>(selection)} {}`
`3782`	`3783`
`3783`	`3784`	`Filtered<T> operator+(is_a_selection auto selection)`
`3784`	`3785`	`{`
`@@ -3908,7 +3909,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>`
`3908`	`3909`	`}`
`3909`	`3910`
`3910`	`3911`	`Filtered(std::vector<Filtered<T>>&& tables, is_a_selection auto selection)`
`3911`		`- : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), selection)`
	`3912`	`+ : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), std::forward<decltype(selection)>(selection))`
`3912`	`3913`	`{`
`3913`	`3914`	`for (auto& table : tables) {`
`3914`	`3915`	`this = table;`