From 6149b0198b3b46e4081120953ea0208b7b1196e0 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Sun, 8 Sep 2024 19:30:51 +0000
Subject: [PATCH 01/28] use generic get() in row_helpers

---
 Framework/Core/include/Framework/ASoA.h       |  6 ++--
 .../Core/include/Framework/ASoAHelpers.h      |  9 ++----
 .../Core/include/Framework/BinningPolicy.h    | 28 +++++++++----------
 3 files changed, 19 insertions(+), 24 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 84c6e3ae705fb..6b26e1394cab7 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2155,7 +2155,7 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
   }
-  return rowIterator.template getDynamicColumn<C>();
+  return static_cast<C>(rowIterator).get();
 }
 
 template <typename T, soa::is_index_column C>
@@ -2168,9 +2168,9 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
 }
 
 template <typename T, typename... Cs>
-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())
+std::tuple<typename Cs::type...> getRowData(T rowIterator, uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
 {
-  return std::make_tuple(getSingleRowData<T, Cs>(table, rowIterator, ci, ai, globalIndex)...);
+  return std::make_tuple(getSingleRowData<T, Cs>(rowIterator, globalIndex)...);
 }
 } // namespace row_helpers
 } // namespace o2::soa
diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 6de6662769ef7..8be26e02999b8 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -75,12 +75,6 @@ inline bool diffCategory(BinningIndex const& a, BinningIndex const& b)
 template <template <typename... Cs> typename BP, typename T, typename... Cs>
 std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPolicy, int minCatSize, int outsider)
 {
-  arrow::Table* arrowTable = table.asArrowTable().get();
-  auto rowIterator = table.begin();
-
-  uint64_t ind = 0;
-  uint64_t selInd = 0;
-  gsl::span<int64_t const> selectedRows;
   std::vector<BinningIndex> groupedIndices;
 
   // Separate check to account for Filtered size different from arrow table
@@ -127,8 +121,9 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
 
       auto values = binningPolicy.getBinningValues(rowIterator, arrowTable, ci, ai, ind);
       auto val = binningPolicy.getBin(values);
+
       if (val != outsider) {
-        groupedIndices.emplace_back(val, ind);
+        groupedIndices.emplace_back(val, *std::get<1>(rowIterator.getIndices()));
       }
       ind++;
 
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index ea04aa3b5a5b3..6ecff761b8a34 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -237,7 +237,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   }
 
   template <typename T, typename T2>
-  auto getBinningValue(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValue(T& rowIterator, uint64_t globalIndex = -1) const
   {
     if constexpr (has_type<T2>(pack<Ls...>{})) {
       if (globalIndex != -1) {
@@ -245,20 +245,20 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
       }
       return std::get<T2>(mBinningFunctions)(rowIterator);
     } else {
-      return soa::row_helpers::getSingleRowData<T, T2>(table, rowIterator, ci, ai, globalIndex);
+      return soa::row_helpers::getSingleRowData<T, T2>(rowIterator, globalIndex);
     }
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, table, ci, ai, globalIndex)...);
+    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   template <typename... T2s>
@@ -280,15 +280,15 @@ struct ColumnBinningPolicy : BinningPolicyBase<sizeof...(Ts)> {
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(table, rowIterator, ci, ai, globalIndex)...);
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(rowIterator, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   int getBin(std::tuple<typename Ts::type...> const& data) const
@@ -305,15 +305,15 @@ struct NoBinningPolicy {
   NoBinningPolicy() = default;
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(table, rowIterator, ci, ai, globalIndex));
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(rowIterator, globalIndex));
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   int getBin(std::tuple<typename C::type> const& data) const

From 2c1c196ca906205e902c9b86de0d5b0e974c3748 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 9 Sep 2024 21:30:22 +0000
Subject: [PATCH 02/28] backward compatibility for binning policy

---
 Framework/Core/include/Framework/BinningPolicy.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 6ecff761b8a34..910e918f4172c 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -256,7 +256,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
     return getBinningValues(rowIterator, globalIndex);
   }
@@ -311,7 +311,7 @@ struct NoBinningPolicy {
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
     return getBinningValues(rowIterator, globalIndex);
   }

From e36ae56f0f564a787e1095424343fae6b6ec7e2e Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 9 Sep 2024 21:31:00 +0000
Subject: [PATCH 03/28] getColumnValueByLabel function

---
 Framework/Core/include/Framework/ASoA.h | 41 +++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 6b26e1394cab7..ed517e3ab6ddb 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2172,6 +2172,47 @@ std::tuple<typename Cs::type...> getRowData(T rowIterator, uint64_t globalIndex
 {
   return std::make_tuple(getSingleRowData<T, Cs>(rowIterator, globalIndex)...);
 }
+
+template <typename R, typename T, typename... Cs>
+std::optional<R> getColumnValueByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string& columnLabel)
+{
+  std::optional<R> value = std::nullopt;
+
+  ([&]() {
+    if (value) {
+      return;
+    }
+
+    if constexpr (std::is_arithmetic_v<typename Cs::type> && std::is_convertible_v<typename Cs::type, R>) {
+      if constexpr (o2::soa::is_dynamic_v<Cs>) {
+        // check if bindings have the same size as lambda parameters (getter do not have additional parameters)
+        if constexpr (o2::framework::pack_size(typename Cs::bindings_t{}) == o2::framework::pack_size(typename Cs::callable_t::args{})) {
+          std::string label = Cs::columnLabel();
+
+          // dynamic columns do not have "f" prefix in columnLabel() return string
+          if (std::strcmp(&columnLabel[1], label.data()) == 0 || columnLabel == label) {
+            value = static_cast<R>(static_cast<Cs>(rowIterator).get());
+          }
+
+        }
+      } else if constexpr (o2::soa::is_persistent_v<Cs> && !o2::soa::is_index_column_v<Cs>) {
+        if (columnLabel == Cs::columnLabel()) {
+          value = static_cast<R>(static_cast<Cs>(rowIterator).get());
+        }
+
+      }
+    }
+  }(),
+   ...);
+
+  return value;
+}
+
+template <typename R, typename T>
+std::optional<R> getColumnValueByLabel(const T& rowIterator, const std::string& columnLabel)
+{
+  return getColumnValueByLabel<R>(typename T::parent_t::table_t::columns{}, rowIterator, columnLabel);
+}
 } // namespace row_helpers
 } // namespace o2::soa
 

From f0a02836be6ac707035eaaf1df04b0833e191e16 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 9 Sep 2024 21:42:02 +0000
Subject: [PATCH 04/28] reverse logic

---
 Framework/Core/include/Framework/ASoA.h | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index ed517e3ab6ddb..8d11a7d35160e 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2187,19 +2187,15 @@ std::optional<R> getColumnValueByLabel(o2::framework::pack<Cs...>, const T& rowI
       if constexpr (o2::soa::is_dynamic_v<Cs>) {
         // check if bindings have the same size as lambda parameters (getter do not have additional parameters)
         if constexpr (o2::framework::pack_size(typename Cs::bindings_t{}) == o2::framework::pack_size(typename Cs::callable_t::args{})) {
-          std::string label = Cs::columnLabel();
-
           // dynamic columns do not have "f" prefix in columnLabel() return string
-          if (std::strcmp(&columnLabel[1], label.data()) == 0 || columnLabel == label) {
+          if (std::strcmp(&columnLabel[1], Cs::columnLabel()) == 0 || std::strcmp(columnLabel.data(), Cs::columnLabel()) == 0) {
             value = static_cast<R>(static_cast<Cs>(rowIterator).get());
           }
-
         }
       } else if constexpr (o2::soa::is_persistent_v<Cs> && !o2::soa::is_index_column_v<Cs>) {
-        if (columnLabel == Cs::columnLabel()) {
+        if (std::strcmp(columnLabel.data(), Cs::columnLabel()) == 0) {
           value = static_cast<R>(static_cast<Cs>(rowIterator).get());
         }
-
       }
     }
   }(),

From 894b4d5674062d8d58ddc4649bdc476815a71c60 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 10 Sep 2024 11:34:18 +0000
Subject: [PATCH 05/28] benchmark for getColumnValueByLabel

---
 Framework/Core/test/benchmark_ASoA.cxx | 66 ++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index 8dfac9e735c0b..96c0e5ab1f86b 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -290,6 +290,41 @@ static void BM_ASoADynamicColumnPresent(benchmark::State& state)
 
 BENCHMARK(BM_ASoADynamicColumnPresent)->Range(8, 8 << maxrange);
 
+static void BM_ASoADynamicColumnPresentGetValueByLabel(benchmark::State& state)
+{
+  // Seed with a real random value, if available
+  std::default_random_engine e1(1234567891);
+  std::uniform_real_distribution<float> uniform_dist(0, 1);
+
+  TableBuilder builder;
+  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
+  for (auto i = 0; i < state.range(0); ++i) {
+    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
+  }
+  auto table = builder.finalize();
+
+  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Z, test::Sum<test::X, test::Y>>;
+
+  std::optional<float> valX, valY;
+  for (auto _ : state) {
+    Test tests{table};
+    float sum = 0;
+    for (auto& test : tests) {
+      valX = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "x");
+      valY = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "y");
+      assert(valX);
+      assert(valY);
+      sum += valX.value() + valY.value();
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
+}
+
+BENCHMARK(BM_ASoADynamicColumnPresentGetValueByLabel)->Range(8, 8 << maxrange);
+
+
+
 static void BM_ASoADynamicColumnCall(benchmark::State& state)
 {
   // Seed with a real random value, if available
@@ -317,4 +352,35 @@ static void BM_ASoADynamicColumnCall(benchmark::State& state)
 }
 BENCHMARK(BM_ASoADynamicColumnCall)->Range(8, 8 << maxrange);
 
+static void BM_ASoADynamicColumnCallGetValueByLabel(benchmark::State& state)
+{
+  // Seed with a real random value, if available
+  std::default_random_engine e1(1234567891);
+  std::uniform_real_distribution<float> uniform_dist(0, 1);
+
+  TableBuilder builder;
+  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
+  for (auto i = 0; i < state.range(0); ++i) {
+    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
+  }
+  auto table = builder.finalize();
+
+  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>>;
+
+  std::optional<float> val;
+  Test tests{table};
+  for (auto _ : state) {
+    float sum = 0;
+    for (auto& test : tests) {
+      val = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "Sum");
+      assert(val);
+      sum += val.value();
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
+}
+BENCHMARK(BM_ASoADynamicColumnCallGetValueByLabel)->Range(8, 8 << maxrange);
+
+
 BENCHMARK_MAIN();

From 88a2ab1f3b7c929332b25d5c921e5217bd287d4c Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 10 Sep 2024 11:47:33 +0000
Subject: [PATCH 06/28] formatting adjustments

---
 Framework/Core/test/benchmark_ASoA.cxx | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index 96c0e5ab1f86b..589673d04ec9f 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -323,8 +323,6 @@ static void BM_ASoADynamicColumnPresentGetValueByLabel(benchmark::State& state)
 
 BENCHMARK(BM_ASoADynamicColumnPresentGetValueByLabel)->Range(8, 8 << maxrange);
 
-
-
 static void BM_ASoADynamicColumnCall(benchmark::State& state)
 {
   // Seed with a real random value, if available
@@ -382,5 +380,4 @@ static void BM_ASoADynamicColumnCallGetValueByLabel(benchmark::State& state)
 }
 BENCHMARK(BM_ASoADynamicColumnCallGetValueByLabel)->Range(8, 8 << maxrange);
 
-
 BENCHMARK_MAIN();

From 75858bbf7e43a6341379cc1dd712bb8b5ee954d7 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Thu, 12 Sep 2024 13:37:05 +0000
Subject: [PATCH 07/28] getColumnGetterByLabel and benchmarks

---
 Framework/Core/include/Framework/ASoA.h | 63 +++++++++++++++++++++++++
 Framework/Core/test/benchmark_ASoA.cxx  | 58 +++++++++++++++++++++++
 2 files changed, 121 insertions(+)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 8d11a7d35160e..232142a17e017 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -30,8 +30,10 @@
 #include <array>
 #include <cassert>
 #include <fmt/format.h>
+#include <functional>
 #include <gsl/span>
 #include <limits>
+#include <stdexcept>
 
 namespace o2::framework
 {
@@ -2209,6 +2211,67 @@ std::optional<R> getColumnValueByLabel(const T& rowIterator, const std::string&
 {
   return getColumnValueByLabel<R>(typename T::parent_t::table_t::columns{}, rowIterator, columnLabel);
 }
+
+template <typename R, typename T, typename Column>
+R getColumnValue(const T& rowIterator)
+{
+  // This directly calls the column's get() method
+  return static_cast<R>(static_cast<Column>(rowIterator).get());
+}
+
+template <typename R, typename T, typename Column>
+using GetFunctionPointer = R (*)(const T&);
+
+template <typename R, typename T, typename Column>
+GetFunctionPointer<R, T, Column> createGetterPtr(const std::string_view& columnLabel, bool& found)
+{
+  using Col = Column;
+
+  if (found) {
+    return nullptr;
+  }
+
+  if constexpr (std::is_arithmetic_v<typename Col::type> && std::is_convertible_v<typename Col::type, R>) {
+    if constexpr (o2::soa::is_dynamic_v<Col>) {
+      if constexpr (o2::framework::pack_size(typename Col::bindings_t{}) == o2::framework::pack_size(typename Col::callable_t::args{})) {
+        if (columnLabel == std::string_view(&Col::columnLabel()[1]) || columnLabel == std::string_view(Col::columnLabel())) {
+          found = true;
+          return &getColumnValue<R, T, Col>;
+        }
+      }
+    } else if constexpr (o2::soa::is_persistent_v<Col> && !o2::soa::is_index_column_v<Col>) {
+      if (columnLabel == std::string_view(Col::columnLabel())) {
+        found = true;
+        return &getColumnValue<R, T, Col>;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+template <typename R, typename T, typename... Cs>
+std::function<R(const T&)> getColumnGetterByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string_view& columnLabel)
+{
+  std::string_view labelView(columnLabel);
+  bool found = false;
+  std::function<R(const T&)> func = nullptr;
+
+  // Iterate through each column in the pack and create the getter function pointer if a match is found
+  (void)((func = createGetterForColumn<R, T, Cs>(labelView, found), found) || ...);
+
+  if (!found) {
+    throw std::runtime_error("Getter for provided columnLabel not found!");
+  }
+
+  return func;
+}
+
+template <typename R, typename T>
+std::function<R(const typename T::iterator&)> getColumnGetterByLabel(const T& table, const std::string_view& columnLabel)
+{
+  return getColumnGetterByLabel<R>(typename T::columns{}, table.begin(), columnLabel);
+}
 } // namespace row_helpers
 } // namespace o2::soa
 
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index 589673d04ec9f..c8294e032e9b4 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -290,6 +290,36 @@ static void BM_ASoADynamicColumnPresent(benchmark::State& state)
 
 BENCHMARK(BM_ASoADynamicColumnPresent)->Range(8, 8 << maxrange);
 
+static void BM_ASoADynamicColumnPresentGetGetterByLabel(benchmark::State& state)
+{
+  // Seed with a real random value, if available
+  std::default_random_engine e1(1234567891);
+  std::uniform_real_distribution<float> uniform_dist(0, 1);
+
+  TableBuilder builder;
+  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
+  for (auto i = 0; i < state.range(0); ++i) {
+    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
+  }
+  auto table = builder.finalize();
+
+  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Z, test::Sum<test::X, test::Y>>;
+
+  for (auto _ : state) {
+    Test tests{table};
+    float sum = 0;
+    auto xGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "x");
+    auto yGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "y");
+    for (auto& test : tests) {
+      sum += xGetter(test) + yGetter(test);
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
+}
+
+BENCHMARK(BM_ASoADynamicColumnPresentGetGetterByLabel)->Range(8, 8 << maxrange);
+
 static void BM_ASoADynamicColumnPresentGetValueByLabel(benchmark::State& state)
 {
   // Seed with a real random value, if available
@@ -350,6 +380,34 @@ static void BM_ASoADynamicColumnCall(benchmark::State& state)
 }
 BENCHMARK(BM_ASoADynamicColumnCall)->Range(8, 8 << maxrange);
 
+static void BM_ASoADynamicColumnCallGetGetterByLabel(benchmark::State& state)
+{
+  // Seed with a real random value, if available
+  std::default_random_engine e1(1234567891);
+  std::uniform_real_distribution<float> uniform_dist(0, 1);
+
+  TableBuilder builder;
+  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
+  for (auto i = 0; i < state.range(0); ++i) {
+    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
+  }
+  auto table = builder.finalize();
+
+  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>>;
+
+  Test tests{table};
+  for (auto _ : state) {
+    float sum = 0;
+    auto sumGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "Sum");
+    for (auto& test : tests) {
+      sum += sumGetter(test);
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
+}
+BENCHMARK(BM_ASoADynamicColumnCallGetGetterByLabel)->Range(8, 8 << maxrange);
+
 static void BM_ASoADynamicColumnCallGetValueByLabel(benchmark::State& state)
 {
   // Seed with a real random value, if available

From 9dabbd3d9af76bbde4f26853db421932b790b0e3 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Thu, 12 Sep 2024 13:43:42 +0000
Subject: [PATCH 08/28] formatting adjustments

---
 Framework/Core/include/Framework/ASoA.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 232142a17e017..dfd0f1e14878f 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -30,10 +30,8 @@
 #include <array>
 #include <cassert>
 #include <fmt/format.h>
-#include <functional>
 #include <gsl/span>
 #include <limits>
-#include <stdexcept>
 
 namespace o2::framework
 {
@@ -1215,7 +1213,7 @@ struct TableIterator : IP, C... {
   {
     static_assert(std::same_as<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
     return &(static_cast<B*>(this)->mColumnIterator);
-    // return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+    //return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
   }
 
   template <typename B>

From 9530b2866579230efbf80cb80d0ac1ac54a7bb39 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Thu, 26 Sep 2024 17:10:51 +0000
Subject: [PATCH 09/28] improve performance by not using std::function

---
 Framework/Core/include/Framework/ASoA.h | 55 ++++-----------------
 Framework/Core/test/benchmark_ASoA.cxx  | 63 -------------------------
 2 files changed, 8 insertions(+), 110 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index dfd0f1e14878f..c0a8038117869 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2173,59 +2173,21 @@ std::tuple<typename Cs::type...> getRowData(T rowIterator, uint64_t globalIndex
   return std::make_tuple(getSingleRowData<T, Cs>(rowIterator, globalIndex)...);
 }
 
-template <typename R, typename T, typename... Cs>
-std::optional<R> getColumnValueByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string& columnLabel)
-{
-  std::optional<R> value = std::nullopt;
-
-  ([&]() {
-    if (value) {
-      return;
-    }
-
-    if constexpr (std::is_arithmetic_v<typename Cs::type> && std::is_convertible_v<typename Cs::type, R>) {
-      if constexpr (o2::soa::is_dynamic_v<Cs>) {
-        // check if bindings have the same size as lambda parameters (getter do not have additional parameters)
-        if constexpr (o2::framework::pack_size(typename Cs::bindings_t{}) == o2::framework::pack_size(typename Cs::callable_t::args{})) {
-          // dynamic columns do not have "f" prefix in columnLabel() return string
-          if (std::strcmp(&columnLabel[1], Cs::columnLabel()) == 0 || std::strcmp(columnLabel.data(), Cs::columnLabel()) == 0) {
-            value = static_cast<R>(static_cast<Cs>(rowIterator).get());
-          }
-        }
-      } else if constexpr (o2::soa::is_persistent_v<Cs> && !o2::soa::is_index_column_v<Cs>) {
-        if (std::strcmp(columnLabel.data(), Cs::columnLabel()) == 0) {
-          value = static_cast<R>(static_cast<Cs>(rowIterator).get());
-        }
-      }
-    }
-  }(),
-   ...);
-
-  return value;
-}
-
-template <typename R, typename T>
-std::optional<R> getColumnValueByLabel(const T& rowIterator, const std::string& columnLabel)
-{
-  return getColumnValueByLabel<R>(typename T::parent_t::table_t::columns{}, rowIterator, columnLabel);
-}
-
 template <typename R, typename T, typename Column>
 R getColumnValue(const T& rowIterator)
 {
-  // This directly calls the column's get() method
   return static_cast<R>(static_cast<Column>(rowIterator).get());
 }
 
-template <typename R, typename T, typename Column>
-using GetFunctionPointer = R (*)(const T&);
+template <typename R, typename T>
+using ColumnGetterFunction = R (*)(const T&);
 
 template <typename R, typename T, typename Column>
-GetFunctionPointer<R, T, Column> createGetterPtr(const std::string_view& columnLabel, bool& found)
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
 {
   using Col = Column;
 
-  if (found) {
+  if(found) {
     return nullptr;
   }
 
@@ -2249,14 +2211,13 @@ GetFunctionPointer<R, T, Column> createGetterPtr(const std::string_view& columnL
 }
 
 template <typename R, typename T, typename... Cs>
-std::function<R(const T&)> getColumnGetterByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string_view& columnLabel)
+ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string_view& columnLabel)
 {
   std::string_view labelView(columnLabel);
   bool found = false;
-  std::function<R(const T&)> func = nullptr;
+  ColumnGetterFunction<R, T> func;
 
-  // Iterate through each column in the pack and create the getter function pointer if a match is found
-  (void)((func = createGetterForColumn<R, T, Cs>(labelView, found), found) || ...);
+  (void)((func = createGetterPtr<R, T, Cs>(labelView, found), found) || ...);
 
   if (!found) {
     throw std::runtime_error("Getter for provided columnLabel not found!");
@@ -2266,7 +2227,7 @@ std::function<R(const T&)> getColumnGetterByLabel(o2::framework::pack<Cs...>, co
 }
 
 template <typename R, typename T>
-std::function<R(const typename T::iterator&)> getColumnGetterByLabel(const T& table, const std::string_view& columnLabel)
+ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const T& table, const std::string_view& columnLabel)
 {
   return getColumnGetterByLabel<R>(typename T::columns{}, table.begin(), columnLabel);
 }
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index c8294e032e9b4..4125eb4edf57e 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -320,39 +320,6 @@ static void BM_ASoADynamicColumnPresentGetGetterByLabel(benchmark::State& state)
 
 BENCHMARK(BM_ASoADynamicColumnPresentGetGetterByLabel)->Range(8, 8 << maxrange);
 
-static void BM_ASoADynamicColumnPresentGetValueByLabel(benchmark::State& state)
-{
-  // Seed with a real random value, if available
-  std::default_random_engine e1(1234567891);
-  std::uniform_real_distribution<float> uniform_dist(0, 1);
-
-  TableBuilder builder;
-  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
-  for (auto i = 0; i < state.range(0); ++i) {
-    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
-  }
-  auto table = builder.finalize();
-
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Z, test::Sum<test::X, test::Y>>;
-
-  std::optional<float> valX, valY;
-  for (auto _ : state) {
-    Test tests{table};
-    float sum = 0;
-    for (auto& test : tests) {
-      valX = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "x");
-      valY = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "y");
-      assert(valX);
-      assert(valY);
-      sum += valX.value() + valY.value();
-    }
-    benchmark::DoNotOptimize(sum);
-  }
-  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
-}
-
-BENCHMARK(BM_ASoADynamicColumnPresentGetValueByLabel)->Range(8, 8 << maxrange);
-
 static void BM_ASoADynamicColumnCall(benchmark::State& state)
 {
   // Seed with a real random value, if available
@@ -408,34 +375,4 @@ static void BM_ASoADynamicColumnCallGetGetterByLabel(benchmark::State& state)
 }
 BENCHMARK(BM_ASoADynamicColumnCallGetGetterByLabel)->Range(8, 8 << maxrange);
 
-static void BM_ASoADynamicColumnCallGetValueByLabel(benchmark::State& state)
-{
-  // Seed with a real random value, if available
-  std::default_random_engine e1(1234567891);
-  std::uniform_real_distribution<float> uniform_dist(0, 1);
-
-  TableBuilder builder;
-  auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
-  for (auto i = 0; i < state.range(0); ++i) {
-    rowWriter(0, uniform_dist(e1), uniform_dist(e1), uniform_dist(e1));
-  }
-  auto table = builder.finalize();
-
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>>;
-
-  std::optional<float> val;
-  Test tests{table};
-  for (auto _ : state) {
-    float sum = 0;
-    for (auto& test : tests) {
-      val = o2::soa::row_helpers::getColumnValueByLabel<float>(test, "Sum");
-      assert(val);
-      sum += val.value();
-    }
-    benchmark::DoNotOptimize(sum);
-  }
-  state.SetBytesProcessed(state.iterations() * state.range(0) * sizeof(float) * 2);
-}
-BENCHMARK(BM_ASoADynamicColumnCallGetValueByLabel)->Range(8, 8 << maxrange);
-
 BENCHMARK_MAIN();

From 326097fbd541ce2c589eb13f39be47e00d329613 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Thu, 26 Sep 2024 17:11:31 +0000
Subject: [PATCH 10/28] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index c0a8038117869..39b9c1ff30bcb 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2187,7 +2187,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel,
 {
   using Col = Column;
 
-  if(found) {
+  if (found) {
     return nullptr;
   }
 

From cb4181127ec4d3472a68c3acae6e325519caf00a Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 30 Sep 2024 17:07:43 +0000
Subject: [PATCH 11/28] remove event mixing changes from this branch

---
 .../Core/include/Framework/ASoAHelpers.h      |  6 ++++
 .../Core/include/Framework/BinningPolicy.h    | 29 +++++++++----------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 8be26e02999b8..0e99571fa9875 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -75,6 +75,12 @@ inline bool diffCategory(BinningIndex const& a, BinningIndex const& b)
 template <template <typename... Cs> typename BP, typename T, typename... Cs>
 std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPolicy, int minCatSize, int outsider)
 {
+  arrow::Table* arrowTable = table.asArrowTable().get();
+  auto rowIterator = table.begin();
+
+  uint64_t ind = 0;
+  uint64_t selInd = 0;
+  gsl::span<int64_t const> selectedRows;
   std::vector<BinningIndex> groupedIndices;
 
   // Separate check to account for Filtered size different from arrow table
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 910e918f4172c..b5e9ba546c4d9 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -12,7 +12,6 @@
 #ifndef FRAMEWORK_BINNINGPOLICY_H
 #define FRAMEWORK_BINNINGPOLICY_H
 
-#include "Framework/ASoA.h"
 #include "Framework/HistogramSpec.h" // only for VARIABLE_WIDTH
 #include "Framework/Pack.h"
 
@@ -237,7 +236,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   }
 
   template <typename T, typename T2>
-  auto getBinningValue(T& rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValue(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
     if constexpr (has_type<T2>(pack<Ls...>{})) {
       if (globalIndex != -1) {
@@ -245,20 +244,20 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
       }
       return std::get<T2>(mBinningFunctions)(rowIterator);
     } else {
-      return soa::row_helpers::getSingleRowData<T, T2>(rowIterator, globalIndex);
+      return soa::row_helpers::getSingleRowData<T, T2>(table, rowIterator, ci, ai, globalIndex);
     }
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, globalIndex)...);
+    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, table, ci, ai, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, globalIndex);
+    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
   }
 
   template <typename... T2s>
@@ -280,15 +279,15 @@ struct ColumnBinningPolicy : BinningPolicyBase<sizeof...(Ts)> {
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(rowIterator, globalIndex)...);
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(table, rowIterator, ci, ai, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, globalIndex);
+    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
   }
 
   int getBin(std::tuple<typename Ts::type...> const& data) const
@@ -305,15 +304,15 @@ struct NoBinningPolicy {
   NoBinningPolicy() = default;
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(rowIterator, globalIndex));
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(table, rowIterator, ci, ai, globalIndex));
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, globalIndex);
+    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
   }
 
   int getBin(std::tuple<typename C::type> const& data) const

From cdc39c5ad301a348e1b02010ee316b6f3520a445 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 1 Oct 2024 08:03:55 +0000
Subject: [PATCH 12/28] add forgotten functions

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 39b9c1ff30bcb..73f2b658df4bd 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2168,9 +2168,9 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
 }
 
 template <typename T, typename... Cs>
-std::tuple<typename Cs::type...> getRowData(T rowIterator, uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
+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())
 {
-  return std::make_tuple(getSingleRowData<T, Cs>(rowIterator, globalIndex)...);
+  return std::make_tuple(getSingleRowData<T, Cs>(table, rowIterator, ci, ai, globalIndex)...);
 }
 
 template <typename R, typename T, typename Column>

From 1d1a7a7dd65eb1ae56dc67bf1ce122f34b81632d Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 8 Oct 2024 06:44:05 +0000
Subject: [PATCH 13/28] fix column name condition for dynamic columns

---
 Framework/Core/include/Framework/ASoA.h | 30 ++++++++++++-------------
 Framework/Core/test/benchmark_ASoA.cxx  |  6 ++---
 2 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 73f2b658df4bd..aeeb317edaa6f 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2173,36 +2173,34 @@ std::tuple<typename Cs::type...> getRowData(arrow::Table* table, T rowIterator,
   return std::make_tuple(getSingleRowData<T, Cs>(table, rowIterator, ci, ai, globalIndex)...);
 }
 
-template <typename R, typename T, typename Column>
+template <typename R, typename T, typename C>
 R getColumnValue(const T& rowIterator)
 {
-  return static_cast<R>(static_cast<Column>(rowIterator).get());
+  return static_cast<R>(static_cast<C>(rowIterator).get());
 }
 
 template <typename R, typename T>
 using ColumnGetterFunction = R (*)(const T&);
 
-template <typename R, typename T, typename Column>
+template <typename R, typename T, typename C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
 {
-  using Col = Column;
-
   if (found) {
     return nullptr;
   }
 
-  if constexpr (std::is_arithmetic_v<typename Col::type> && std::is_convertible_v<typename Col::type, R>) {
-    if constexpr (o2::soa::is_dynamic_v<Col>) {
-      if constexpr (o2::framework::pack_size(typename Col::bindings_t{}) == o2::framework::pack_size(typename Col::callable_t::args{})) {
-        if (columnLabel == std::string_view(&Col::columnLabel()[1]) || columnLabel == std::string_view(Col::columnLabel())) {
+  if constexpr (std::is_arithmetic_v<typename C::type> && std::is_convertible_v<typename C::type, R>) {
+    if constexpr (o2::soa::is_dynamic_v<C>) {
+      if constexpr (o2::framework::pack_size(typename C::bindings_t{}) == o2::framework::pack_size(typename C::callable_t::args{})) {
+        if (std::string_view(&columnLabel[1]) == std::string_view(C::columnLabel()) || columnLabel == std::string_view(C::columnLabel())) {
           found = true;
-          return &getColumnValue<R, T, Col>;
+          return &getColumnValue<R, T, C>;
         }
       }
-    } else if constexpr (o2::soa::is_persistent_v<Col> && !o2::soa::is_index_column_v<Col>) {
-      if (columnLabel == std::string_view(Col::columnLabel())) {
+    } else if constexpr (o2::soa::is_persistent_v<C> && !o2::soa::is_index_column_v<C>) {
+      if (columnLabel == std::string_view(C::columnLabel())) {
         found = true;
-        return &getColumnValue<R, T, Col>;
+        return &getColumnValue<R, T, C>;
       }
     }
   }
@@ -2211,7 +2209,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel,
 }
 
 template <typename R, typename T, typename... Cs>
-ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const T& rowIterator, const std::string_view& columnLabel)
+ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& columnLabel)
 {
   std::string_view labelView(columnLabel);
   bool found = false;
@@ -2227,9 +2225,9 @@ ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, co
 }
 
 template <typename R, typename T>
-ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const T& table, const std::string_view& columnLabel)
+ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& columnLabel)
 {
-  return getColumnGetterByLabel<R>(typename T::columns{}, table.begin(), columnLabel);
+  return getColumnGetterByLabel<R, typename T::iterator>(typename T::columns{}, columnLabel);
 }
 } // namespace row_helpers
 } // namespace o2::soa
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index 4125eb4edf57e..dc21b10fa0306 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -308,8 +308,8 @@ static void BM_ASoADynamicColumnPresentGetGetterByLabel(benchmark::State& state)
   for (auto _ : state) {
     Test tests{table};
     float sum = 0;
-    auto xGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "x");
-    auto yGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "y");
+    auto xGetter = o2::soa::row_helpers::getColumnGetterByLabel<float, Test>("x");
+    auto yGetter = o2::soa::row_helpers::getColumnGetterByLabel<float, Test>("y");
     for (auto& test : tests) {
       sum += xGetter(test) + yGetter(test);
     }
@@ -365,7 +365,7 @@ static void BM_ASoADynamicColumnCallGetGetterByLabel(benchmark::State& state)
   Test tests{table};
   for (auto _ : state) {
     float sum = 0;
-    auto sumGetter = o2::soa::row_helpers::getColumnGetterByLabel<float>(tests, "Sum");
+    auto sumGetter = o2::soa::row_helpers::getColumnGetterByLabel<float, Test>("Sum");
     for (auto& test : tests) {
       sum += sumGetter(test);
     }

From 3ac18fc77cf0def92e182ea1cdc88690f4561bf3 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Sun, 13 Oct 2024 18:44:00 +0000
Subject: [PATCH 14/28] style improvements + using concepts for conditional
 code and selecting types

---
 Framework/Core/include/Framework/ASoA.h | 57 ++++++++++++++++---------
 Framework/Core/test/benchmark_ASoA.cxx  |  4 +-
 2 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index aeeb317edaa6f..3e82e782ed28a 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -30,6 +30,7 @@
 #include <array>
 #include <cassert>
 #include <fmt/format.h>
+#include <concepts>
 #include <gsl/span>
 #include <limits>
 
@@ -2182,40 +2183,51 @@ R getColumnValue(const T& rowIterator)
 template <typename R, typename T>
 using ColumnGetterFunction = R (*)(const T&);
 
-template <typename R, typename T, typename C>
+template <typename T, typename R>
+concept dynamic_with_common_getter = is_dynamic_v<T> && 
+  // lambda is callable without additional free args
+  framework::pack_size(typename T::bindings_t{}) == framework::pack_size(typename T::callable_t::args{}) &&
+  requires (T t)
+{
+  { t.get() } -> std::convertible_to<R>;
+};
+
+template <typename T, typename R>
+concept persistent_with_common_getter = is_persistent_v<T> && requires (T t)
+{
+  { t.get() } -> std::convertible_to<R>;
+};
+
+template <typename T, typename R>
+using 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;
+
+template <typename R, typename T, persistent_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
 {
-  if (found) {
-    return nullptr;
-  }
+    if (std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
+      found = true;
+    }
 
-  if constexpr (std::is_arithmetic_v<typename C::type> && std::is_convertible_v<typename C::type, R>) {
-    if constexpr (o2::soa::is_dynamic_v<C>) {
-      if constexpr (o2::framework::pack_size(typename C::bindings_t{}) == o2::framework::pack_size(typename C::callable_t::args{})) {
-        if (std::string_view(&columnLabel[1]) == std::string_view(C::columnLabel()) || columnLabel == std::string_view(C::columnLabel())) {
-          found = true;
-          return &getColumnValue<R, T, C>;
-        }
-      }
-    } else if constexpr (o2::soa::is_persistent_v<C> && !o2::soa::is_index_column_v<C>) {
-      if (columnLabel == std::string_view(C::columnLabel())) {
+    return &getColumnValue<R, T, C>;
+}
+
+template <typename R, typename T, dynamic_with_common_getter<R> C>
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
+{
+    if (std::strcmp(&columnLabel[1], C::columnLabel()) == 0 || std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
         found = true;
-        return &getColumnValue<R, T, C>;
-      }
     }
-  }
 
-  return nullptr;
+    return &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, typename... Cs>
 ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& columnLabel)
 {
-  std::string_view labelView(columnLabel);
   bool found = false;
   ColumnGetterFunction<R, T> func;
 
-  (void)((func = createGetterPtr<R, T, Cs>(labelView, found), found) || ...);
+  (void)((func = createGetterPtr<R, T, Cs>(columnLabel, found), found) || ...);
 
   if (!found) {
     throw std::runtime_error("Getter for provided columnLabel not found!");
@@ -2227,7 +2239,9 @@ ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, co
 template <typename R, typename T>
 ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& columnLabel)
 {
-  return getColumnGetterByLabel<R, typename T::iterator>(typename T::columns{}, columnLabel);
+  using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns>;
+
+  return getColumnGetterByLabel<R, typename T::iterator>(TypesWithCommonGetter{}, columnLabel);
 }
 } // namespace row_helpers
 } // namespace o2::soa
@@ -2990,6 +3004,7 @@ consteval auto getIndexTargets()
     }                                                                                                                      \
                                                                                                                            \
     using bindings_t = typename o2::framework::pack<Bindings...>;                                                          \
+    using bindings_types_t = typename o2::framework::pack<typename Bindings::type...>;                                              \
     std::tuple<o2::soa::ColumnIterator<typename Bindings::type> const*...> boundIterators;                                 \
   }
 
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index dc21b10fa0306..a60bd51a50ea8 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -29,6 +29,7 @@ DECLARE_SOA_COLUMN_FULL(X, x, float, "x");
 DECLARE_SOA_COLUMN_FULL(Y, y, float, "y");
 DECLARE_SOA_COLUMN_FULL(Z, z, float, "z");
 DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](float x, float y) { return x + y; });
+DECLARE_SOA_DYNAMIC_COLUMN(SumFreeArgs, sumFreeArgs, [](float x, float y, float freeArg) { return x + y + freeArg; });
 } // namespace test
 
 DECLARE_SOA_TABLE(TestTable, "AOD", "TESTTBL", test::X, test::Y, test::Z, test::Sum<test::X, test::Y>);
@@ -360,7 +361,8 @@ static void BM_ASoADynamicColumnCallGetGetterByLabel(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>>;
+  // SumFreeArgs presence checks if dynamic columns get() is handled correctly during compilation
+  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>, test::SumFreeArgs<test::X, test::Y>>;
 
   Test tests{table};
   for (auto _ : state) {

From 5ae776d3de6c5e80b29b9abb7ed855d430be766f Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Sun, 13 Oct 2024 18:44:40 +0000
Subject: [PATCH 15/28] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h | 34 ++++++++++++-------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 3e82e782ed28a..8a7818f7de717 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2184,17 +2184,15 @@ template <typename R, typename T>
 using ColumnGetterFunction = R (*)(const T&);
 
 template <typename T, typename R>
-concept dynamic_with_common_getter = is_dynamic_v<T> && 
-  // lambda is callable without additional free args
-  framework::pack_size(typename T::bindings_t{}) == framework::pack_size(typename T::callable_t::args{}) &&
-  requires (T t)
-{
-  { t.get() } -> std::convertible_to<R>;
-};
+concept dynamic_with_common_getter = is_dynamic_v<T> &&
+                                     // lambda is callable without additional free args
+                                     framework::pack_size(typename T::bindings_t{}) == framework::pack_size(typename T::callable_t::args{}) &&
+                                     requires(T t) {
+                                       { t.get() } -> std::convertible_to<R>;
+                                     };
 
 template <typename T, typename R>
-concept persistent_with_common_getter = is_persistent_v<T> && requires (T t)
-{
+concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
   { t.get() } -> std::convertible_to<R>;
 };
 
@@ -2204,21 +2202,21 @@ using with_common_getter_t = typename std::conditional<persistent_with_common_ge
 template <typename R, typename T, persistent_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
 {
-    if (std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
-      found = true;
-    }
+  if (std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
+    found = true;
+  }
 
-    return &getColumnValue<R, T, C>;
+  return &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
 {
-    if (std::strcmp(&columnLabel[1], C::columnLabel()) == 0 || std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
-        found = true;
-    }
+  if (std::strcmp(&columnLabel[1], C::columnLabel()) == 0 || std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
+    found = true;
+  }
 
-    return &getColumnValue<R, T, C>;
+  return &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, typename... Cs>
@@ -3004,7 +3002,7 @@ consteval auto getIndexTargets()
     }                                                                                                                      \
                                                                                                                            \
     using bindings_t = typename o2::framework::pack<Bindings...>;                                                          \
-    using bindings_types_t = typename o2::framework::pack<typename Bindings::type...>;                                              \
+    using bindings_types_t = typename o2::framework::pack<typename Bindings::type...>;                                     \
     std::tuple<o2::soa::ColumnIterator<typename Bindings::type> const*...> boundIterators;                                 \
   }
 

From 9b7900abd8d61ffc50155069b57ce21059d866a9 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 14 Oct 2024 08:14:48 +0000
Subject: [PATCH 16/28] remove bindings_types_t

---
 Framework/Core/include/Framework/ASoA.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 8a7818f7de717..4e3c477d2233a 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -3002,7 +3002,6 @@ consteval auto getIndexTargets()
     }                                                                                                                      \
                                                                                                                            \
     using bindings_t = typename o2::framework::pack<Bindings...>;                                                          \
-    using bindings_types_t = typename o2::framework::pack<typename Bindings::type...>;                                     \
     std::tuple<o2::soa::ColumnIterator<typename Bindings::type> const*...> boundIterators;                                 \
   }
 

From 70d5a251fdc18eb30b650a7045c6b0f327d7a7c1 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 14 Oct 2024 11:48:56 +0000
Subject: [PATCH 17/28] use strncmp and use nullptr as fallback

---
 Framework/Core/include/Framework/ASoA.h | 28 ++++++++++++++-----------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4e3c477d2233a..16aee758a87fa 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -31,6 +31,7 @@
 #include <cassert>
 #include <fmt/format.h>
 #include <concepts>
+#include <cstring>
 #include <gsl/span>
 #include <limits>
 
@@ -2200,35 +2201,38 @@ template <typename T, typename R>
 using 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;
 
 template <typename R, typename T, persistent_with_common_getter<R> C>
-ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
-  if (std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
-    found = true;
+  const size_t n = columnLabel.size();
+
+  if(n == 0 || n != strlen(C::columnLabel())) {
+    return nullptr;
   }
 
-  return &getColumnValue<R, T, C>;
+  return (std::strncmp(columnLabel.data(), C::columnLabel(), n)) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
-ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel, bool& found)
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
-  if (std::strcmp(&columnLabel[1], C::columnLabel()) == 0 || std::strcmp(columnLabel.data(), C::columnLabel()) == 0) {
-    found = true;
+  const size_t n = columnLabel.size();
+
+  if(n == 0 || n != strlen(C::columnLabel())) {
+    return nullptr;
   }
 
-  return &getColumnValue<R, T, C>;
+  return ((std::strncmp(&columnLabel[1], C::columnLabel(), n-1) && std::strncmp(columnLabel.data(), C::columnLabel(), n))) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, typename... Cs>
 ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& columnLabel)
 {
-  bool found = false;
   ColumnGetterFunction<R, T> func;
 
-  (void)((func = createGetterPtr<R, T, Cs>(columnLabel, found), found) || ...);
+  (void)((func = createGetterPtr<R, T, Cs>(columnLabel), func) || ...);
 
-  if (!found) {
-    throw std::runtime_error("Getter for provided columnLabel not found!");
+  if (!func) {
+    throw framework::runtime_error("Getter for provided columnLabel not found!");
   }
 
   return func;

From bc699c8b64f39b8cf553a3b9e7f716710e009619 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Mon, 14 Oct 2024 11:49:39 +0000
Subject: [PATCH 18/28] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 16aee758a87fa..0be596d50620f 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2205,7 +2205,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   const size_t n = columnLabel.size();
 
-  if(n == 0 || n != strlen(C::columnLabel())) {
+  if (n == 0 || n != strlen(C::columnLabel())) {
     return nullptr;
   }
 
@@ -2217,11 +2217,11 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   const size_t n = columnLabel.size();
 
-  if(n == 0 || n != strlen(C::columnLabel())) {
+  if (n == 0 || n != strlen(C::columnLabel())) {
     return nullptr;
   }
 
-  return ((std::strncmp(&columnLabel[1], C::columnLabel(), n-1) && std::strncmp(columnLabel.data(), C::columnLabel(), n))) ? nullptr : &getColumnValue<R, T, C>;
+  return ((std::strncmp(&columnLabel[1], C::columnLabel(), n - 1) && std::strncmp(columnLabel.data(), C::columnLabel(), n))) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, typename... Cs>

From d7db3c2506e522c6a30107869ea8d6b85e8b45b1 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 14 Oct 2024 16:49:52 +0000
Subject: [PATCH 19/28] use strcmp

---
 Framework/Core/include/Framework/ASoA.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 0be596d50620f..96595182a0932 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2197,9 +2197,6 @@ concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
   { t.get() } -> std::convertible_to<R>;
 };
 
-template <typename T, typename R>
-using 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;
-
 template <typename R, typename T, persistent_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
@@ -2209,7 +2206,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
     return nullptr;
   }
 
-  return (std::strncmp(columnLabel.data(), C::columnLabel(), n)) ? nullptr : &getColumnValue<R, T, C>;
+  return (std::strcmp(columnLabel.data(), C::columnLabel())) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
@@ -2221,7 +2218,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
     return nullptr;
   }
 
-  return ((std::strncmp(&columnLabel[1], C::columnLabel(), n - 1) && std::strncmp(columnLabel.data(), C::columnLabel(), n))) ? nullptr : &getColumnValue<R, T, C>;
+  return ((std::strcmp(&columnLabel[1], C::columnLabel()) && std::strcmp(columnLabel.data(), C::columnLabel()))) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, typename... Cs>
@@ -2238,6 +2235,9 @@ ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, co
   return func;
 }
 
+template <typename T, typename R>
+using 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;
+
 template <typename R, typename T>
 ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& columnLabel)
 {

From 84e5c7fbd47eb3574d3b8cab7515cccd4e7bb0d2 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 15 Oct 2024 05:24:37 +0000
Subject: [PATCH 20/28] fix dynamic column logic

---
 Framework/Core/include/Framework/ASoA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 96595182a0932..faeeb302ae6d1 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2214,7 +2214,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   const size_t n = columnLabel.size();
 
-  if (n == 0 || n != strlen(C::columnLabel())) {
+  if (n == 0 || (n != strlen(C::columnLabel()) && n-1 != strlen(C::columnLabel()))) {
     return nullptr;
   }
 

From 34b3461f0a29b76ea0c762e101d0a98e10e40943 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Tue, 15 Oct 2024 05:25:15 +0000
Subject: [PATCH 21/28] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index faeeb302ae6d1..1c5ce1afc76ed 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2214,7 +2214,7 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   const size_t n = columnLabel.size();
 
-  if (n == 0 || (n != strlen(C::columnLabel()) && n-1 != strlen(C::columnLabel()))) {
+  if (n == 0 || (n != strlen(C::columnLabel()) && n - 1 != strlen(C::columnLabel()))) {
     return nullptr;
   }
 

From 1c49418bd8f2bb8a364712406553f9c8a86c1b5a Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Thu, 14 Nov 2024 13:49:21 +0000
Subject: [PATCH 22/28] refactor string comparison

---
 Framework/Core/include/Framework/ASoA.h | 26 ++++++++++++-------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 1c5ce1afc76ed..8434e4743cdd1 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2200,25 +2200,19 @@ concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
 template <typename R, typename T, persistent_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
-  const size_t n = columnLabel.size();
-
-  if (n == 0 || n != strlen(C::columnLabel())) {
-    return nullptr;
-  }
-
-  return (std::strcmp(columnLabel.data(), C::columnLabel())) ? nullptr : &getColumnValue<R, T, C>;
+  return std::strncmp(columnLabel.data(), C::columnLabel(), columnLabel.size()) ? nullptr : &getColumnValue<R, T, C>;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
-  const size_t n = columnLabel.size();
+  // allows user to use consistent formatting (with prefix) of all column labels
+  // by default there isn't 'f' prefix for dynamic column labels, strncmp(x,y,0) is always 0
+  bool isPrefixMatch = columnLabel.size() > 1 && !std::strncmp(columnLabel.substr(1).data(), C::columnLabel(), columnLabel.size() - 1);
+  // check also exact match if user is aware of prefix missing
+  bool isExactMatch = !std::strncmp(columnLabel.data(), C::columnLabel(), columnLabel.size());
 
-  if (n == 0 || (n != strlen(C::columnLabel()) && n - 1 != strlen(C::columnLabel()))) {
-    return nullptr;
-  }
-
-  return ((std::strcmp(&columnLabel[1], C::columnLabel()) && std::strcmp(columnLabel.data(), C::columnLabel()))) ? nullptr : &getColumnValue<R, T, C>;
+  return (isPrefixMatch || isExactMatch) ? &getColumnValue<R, T, C> : nullptr;
 }
 
 template <typename R, typename T, typename... Cs>
@@ -2229,7 +2223,7 @@ ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, co
   (void)((func = createGetterPtr<R, T, Cs>(columnLabel), func) || ...);
 
   if (!func) {
-    throw framework::runtime_error("Getter for provided columnLabel not found!");
+    throw framework::runtime_error_f("Getter for \"%s\" not found", columnLabel);
   }
 
   return func;
@@ -2243,6 +2237,10 @@ ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::
 {
   using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns>;
 
+  if (columnLabel.size() == 0) {
+    throw framework::runtime_error("columnLabel: must not be empty");
+  }
+
   return getColumnGetterByLabel<R, typename T::iterator>(TypesWithCommonGetter{}, columnLabel);
 }
 } // namespace row_helpers

From 3d19a4ba526d5a8394ccb48eb829d53990eb048e Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Thu, 14 Nov 2024 20:44:26 +0000
Subject: [PATCH 23/28] fix edge case

---
 Framework/Core/include/Framework/ASoA.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 8434e4743cdd1..cdd1f29b05938 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2200,17 +2200,17 @@ concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
 template <typename R, typename T, persistent_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
-  return std::strncmp(columnLabel.data(), C::columnLabel(), columnLabel.size()) ? nullptr : &getColumnValue<R, T, C>;
+  return columnLabel == C::columnLabel() ? &getColumnValue<R, T, C> : nullptr;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
 ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   // allows user to use consistent formatting (with prefix) of all column labels
-  // by default there isn't 'f' prefix for dynamic column labels, strncmp(x,y,0) is always 0
-  bool isPrefixMatch = columnLabel.size() > 1 && !std::strncmp(columnLabel.substr(1).data(), C::columnLabel(), columnLabel.size() - 1);
+  // by default there isn't 'f' prefix for dynamic column labels
+  bool isPrefixMatch = columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel();
   // check also exact match if user is aware of prefix missing
-  bool isExactMatch = !std::strncmp(columnLabel.data(), C::columnLabel(), columnLabel.size());
+  bool isExactMatch = columnLabel == C::columnLabel();
 
   return (isPrefixMatch || isExactMatch) ? &getColumnValue<R, T, C> : nullptr;
 }

From a82619c4685b93ad0f8d70984d89a83033844115 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Fri, 15 Nov 2024 11:45:33 +0000
Subject: [PATCH 24/28] use early return

---
 Framework/Core/include/Framework/ASoA.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index cdd1f29b05938..ed6a85c2dc533 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2208,11 +2208,16 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   // allows user to use consistent formatting (with prefix) of all column labels
   // by default there isn't 'f' prefix for dynamic column labels
-  bool isPrefixMatch = columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel();
+  if(columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel()) {
+    return &getColumnValue<R, T, C>;
+  }
+
   // check also exact match if user is aware of prefix missing
-  bool isExactMatch = columnLabel == C::columnLabel();
+  if(columnLabel == C::columnLabel()) {
+    return &getColumnValue<R, T, C>;
+  }
 
-  return (isPrefixMatch || isExactMatch) ? &getColumnValue<R, T, C> : nullptr;
+  return nullptr;
 }
 
 template <typename R, typename T, typename... Cs>

From be2082405c32f37600aa934d04ab32397091c9c5 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Fri, 15 Nov 2024 11:47:14 +0000
Subject: [PATCH 25/28] formatting

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index ed6a85c2dc533..f01dd989fe76e 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2208,12 +2208,12 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 {
   // allows user to use consistent formatting (with prefix) of all column labels
   // by default there isn't 'f' prefix for dynamic column labels
-  if(columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel()) {
+  if (columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel()) {
     return &getColumnValue<R, T, C>;
   }
 
   // check also exact match if user is aware of prefix missing
-  if(columnLabel == C::columnLabel()) {
+  if (columnLabel == C::columnLabel()) {
     return &getColumnValue<R, T, C>;
   }
 

From 6d1f8e6fe63021ede1a9d689fc3aae40e53fbb01 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Fri, 15 Nov 2024 15:12:36 +0000
Subject: [PATCH 26/28] use temporary string_view and starts_with method

---
 Framework/Core/include/Framework/ASoA.h | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index f01dd989fe76e..095c516ae3356 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2198,22 +2198,24 @@ concept persistent_with_common_getter = is_persistent_v<T> && requires(T t) {
 };
 
 template <typename R, typename T, persistent_with_common_getter<R> C>
-ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& targetColumnLabel)
 {
-  return columnLabel == C::columnLabel() ? &getColumnValue<R, T, C> : nullptr;
+  return targetColumnLabel == C::columnLabel() ? &getColumnValue<R, T, C> : nullptr;
 }
 
 template <typename R, typename T, dynamic_with_common_getter<R> C>
-ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
+ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& targetColumnLabel)
 {
+  std::string_view columnLabel(C::columnLabel());
+
   // allows user to use consistent formatting (with prefix) of all column labels
   // by default there isn't 'f' prefix for dynamic column labels
-  if (columnLabel.size() > 1 && columnLabel.substr(1) == C::columnLabel()) {
+  if (targetColumnLabel.starts_with("f") && targetColumnLabel.substr(1) == columnLabel) {
     return &getColumnValue<R, T, C>;
   }
 
   // check also exact match if user is aware of prefix missing
-  if (columnLabel == C::columnLabel()) {
+  if (targetColumnLabel == columnLabel) {
     return &getColumnValue<R, T, C>;
   }
 
@@ -2221,14 +2223,14 @@ ColumnGetterFunction<R, T> createGetterPtr(const std::string_view& columnLabel)
 }
 
 template <typename R, typename T, typename... Cs>
-ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& columnLabel)
+ColumnGetterFunction<R, T> getColumnGetterByLabel(o2::framework::pack<Cs...>, const std::string_view& targetColumnLabel)
 {
   ColumnGetterFunction<R, T> func;
 
-  (void)((func = createGetterPtr<R, T, Cs>(columnLabel), func) || ...);
+  (void)((func = createGetterPtr<R, T, Cs>(targetColumnLabel), func) || ...);
 
   if (!func) {
-    throw framework::runtime_error_f("Getter for \"%s\" not found", columnLabel);
+    throw framework::runtime_error_f("Getter for \"%s\" not found", targetColumnLabel);
   }
 
   return func;
@@ -2238,15 +2240,15 @@ template <typename T, typename R>
 using 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;
 
 template <typename R, typename T>
-ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& columnLabel)
+ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& targetColumnLabel)
 {
   using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns>;
 
-  if (columnLabel.size() == 0) {
+  if (targetColumnLabel.size() == 0) {
     throw framework::runtime_error("columnLabel: must not be empty");
   }
 
-  return getColumnGetterByLabel<R, typename T::iterator>(TypesWithCommonGetter{}, columnLabel);
+  return getColumnGetterByLabel<R, typename T::iterator>(TypesWithCommonGetter{}, targetColumnLabel);
 }
 } // namespace row_helpers
 } // namespace o2::soa

From 6861013c256fbdaaf25b5265e8fb3986d8d6fe3a Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 10 Dec 2024 19:11:52 +0000
Subject: [PATCH 27/28] post rebase fixes

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 Framework/Core/test/benchmark_ASoA.cxx  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 095c516ae3356..12c3397de76b8 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2185,7 +2185,7 @@ template <typename R, typename T>
 using ColumnGetterFunction = R (*)(const T&);
 
 template <typename T, typename R>
-concept dynamic_with_common_getter = is_dynamic_v<T> &&
+concept dynamic_with_common_getter = is_dynamic_column<T> &&
                                      // lambda is callable without additional free args
                                      framework::pack_size(typename T::bindings_t{}) == framework::pack_size(typename T::callable_t::args{}) &&
                                      requires(T t) {
@@ -2242,7 +2242,7 @@ using with_common_getter_t = typename std::conditional<persistent_with_common_ge
 template <typename R, typename T>
 ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::string_view& targetColumnLabel)
 {
-  using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns>;
+  using TypesWithCommonGetter = o2::framework::selected_pack_multicondition<with_common_getter_t, framework::pack<R>, typename T::columns_t>;
 
   if (targetColumnLabel.size() == 0) {
     throw framework::runtime_error("columnLabel: must not be empty");
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index a60bd51a50ea8..4001e2a725a15 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -304,7 +304,7 @@ static void BM_ASoADynamicColumnPresentGetGetterByLabel(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Z, test::Sum<test::X, test::Y>>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X, test::Y, test::Z, test::Sum<test::X, test::Y>>;
 
   for (auto _ : state) {
     Test tests{table};
@@ -362,7 +362,7 @@ static void BM_ASoADynamicColumnCallGetGetterByLabel(benchmark::State& state)
   auto table = builder.finalize();
 
   // SumFreeArgs presence checks if dynamic columns get() is handled correctly during compilation
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Sum<test::X, test::Y>, test::SumFreeArgs<test::X, test::Y>>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X, test::Y, test::Sum<test::X, test::Y>, test::SumFreeArgs<test::X, test::Y>>;
 
   Test tests{table};
   for (auto _ : state) {

From 1ec13536c09cb4f31344b9ef569eebf7d1922a03 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Tue, 10 Dec 2024 20:11:52 +0000
Subject: [PATCH 28/28] fix formatting

---
 Framework/Core/include/Framework/ASoA.h        | 4 ++--
 Framework/Core/include/Framework/ASoAHelpers.h | 3 +--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 12c3397de76b8..cfece12767612 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1215,7 +1215,7 @@ struct TableIterator : IP, C... {
   {
     static_assert(std::same_as<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
     return &(static_cast<B*>(this)->mColumnIterator);
-    //return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+    // return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
   }
 
   template <typename B>
@@ -2157,7 +2157,7 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
   }
-  return static_cast<C>(rowIterator).get();
+  return rowIterator.template getDynamicColumn<C>();
 }
 
 template <typename T, soa::is_index_column C>
diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 0e99571fa9875..6de6662769ef7 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -127,9 +127,8 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
 
       auto values = binningPolicy.getBinningValues(rowIterator, arrowTable, ci, ai, ind);
       auto val = binningPolicy.getBin(values);
-
       if (val != outsider) {
-        groupedIndices.emplace_back(val, *std::get<1>(rowIterator.getIndices()));
+        groupedIndices.emplace_back(val, ind);
       }
       ind++;