diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerHelpers.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerHelpers.h
index 9ef05096b2fd2..5351504443269 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerHelpers.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerHelpers.h
@@ -18,8 +18,6 @@
 #include <boost/functional/hash.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/unordered_map.hpp>
-#include <string>
-#include <vector>
 #include <Framework/AnalysisHelpers.h>
 
 namespace o2::aodhelpers
@@ -55,7 +53,7 @@ auto createTableCursor(framework::ProcessingContext& pc)
   framework::Produces<T> c;
   c.resetCursor(pc.outputs()
                   .make<framework::TableBuilder>(framework::OutputForTable<T>::ref()));
-  c.setLabel(o2::aod::MetadataTrait<T>::metadata::tableLabel());
+  c.setLabel(aod::label<T::ref>());
   return c;
 }
 } // namespace o2::aodhelpers
diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index d9481917f9a05..eaaf2d9eaedd9 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -21,7 +21,6 @@
 #include "DataFormatsTRD/TrackTRD.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "DetectorsBase/Propagator.h"
-#include "Framework/AnalysisHelpers.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
@@ -36,7 +35,6 @@
 #include <cstdint>
 #include <limits>
 #include <set>
-#include <string>
 #include <vector>
 #include <random>
 using namespace o2::framework;
diff --git a/Detectors/AOD/src/StandaloneAODProducer.cxx b/Detectors/AOD/src/StandaloneAODProducer.cxx
index a9f5a09141d8c..7ac59a556ac08 100644
--- a/Detectors/AOD/src/StandaloneAODProducer.cxx
+++ b/Detectors/AOD/src/StandaloneAODProducer.cxx
@@ -94,7 +94,7 @@ void fillMCollisionTable(o2::steer::MCKinematicsReader const& mcreader)
 
   TFile outfile("aod.root", "UPDATE");
   {
-    TableToTree t2t(mccoltable, &outfile, aod::MetadataTrait<o2::aod::McCollisions>::metadata::tableLabel());
+    TableToTree t2t(mccoltable, &outfile, aod::description_str(aod::signature<o2::aod::McCollisions::ref>()).data());
     t2t.addAllBranches();
     t2t.process();
   }
@@ -200,12 +200,12 @@ void fillCollisionAndTrackTable()
       f.Close();
       TFile outfile("aod.root", "RECREATE");
       {
-        TableToTree t2t(colltable, &outfile, aod::MetadataTrait<o2::aod::Collisions>::metadata::tableLabel());
+        TableToTree t2t(colltable, &outfile, aod::description_str(aod::signature<o2::aod::Collisions::ref>()).data());
         t2t.addAllBranches();
         t2t.process();
       }
       {
-        TableToTree t2t(tracktable, &outfile, "Tracks" /* aod::MetadataTrait<o2::aod::Tracks>::metadata::tableLabel() */);
+        TableToTree t2t(tracktable, &outfile, aod::description_str(aod::signature<o2::aod::StoredTracks::ref>()).data());
         t2t.addAllBranches();
         t2t.process();
       }
diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 02367afdcc556..5cdd1241ecfb0 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -236,6 +236,7 @@ add_executable(o2-test-framework-core
               test/test_Services.cxx
               test/test_StringHelpers.cxx
               test/test_StaticFor.cxx
+              test/test_TableSpawner.cxx
               test/test_TMessageSerializer.cxx
               test/test_TableBuilder.cxx
               test/test_TimeParallelPipelining.cxx
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 34d18476e483d..25e64daefeba7 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -15,6 +15,7 @@
 #include "Framework/Pack.h"
 #include "Framework/FunctionalHelpers.h"
 #include "Headers/DataHeader.h"
+#include "Headers/DataHeaderHelpers.h"
 #include "Framework/CompilerBuiltins.h"
 #include "Framework/Traits.h"
 #include "Framework/Expressions.h"
@@ -26,152 +27,362 @@
 #include <arrow/array.h>
 #include <arrow/util/config.h>
 #include <gandiva/selection_vector.h>
+#include <array>
 #include <cassert>
 #include <fmt/format.h>
 #include <gsl/span>
 #include <limits>
 
-#define DECLARE_SOA_METADATA()       \
-  template <typename T>              \
-  struct MetadataTrait {             \
-    using metadata = std::void_t<T>; \
-  };
-
-#define DECLARE_SOA_ITERATOR_METADATA()                                       \
-  template <typename IT>                                                      \
-    requires(o2::soa::is_iterator<IT>)                                        \
-  struct MetadataTrait<IT> {                                                  \
-    using metadata = typename MetadataTrait<typename IT::parent_t>::metadata; \
-  };
-
 namespace o2::framework
 {
 using ListVector = std::vector<std::vector<int64_t>>;
 
 std::string cutString(std::string&& str);
+std::string strToUpper(std::string&& str);
+} // namespace o2::framework
 
-struct OriginEnc {
-  static constexpr size_t size = 4;
-  uint32_t value;
-  consteval OriginEnc(uint32_t v) : value{v}
-  {
-  }
-  consteval OriginEnc(std::string_view in) : value{0}
+namespace o2::soa
+{
+void accessingInvalidIndexFor(const char* getter);
+void dereferenceWithWrongType();
+void missingFilterDeclaration(int hash, int ai);
+void notBoundTable(const char* tableName);
+} // namespace o2::soa
+
+namespace o2::soa
+{
+/// Generic identifier for a table type
+struct TableRef {
+  consteval TableRef()
+    : label_hash{0},
+      desc_hash{0},
+      origin_hash{0},
+      version{0}
   {
-    for (auto i = 0U; i < (size < in.size() ? size : in.size()); ++i) {
-      value |= ((uint8_t)in[i]) << (8 * i);
-    }
   }
-  operator const char*() const
+  consteval TableRef(uint32_t _label, uint32_t _desc, uint32_t _origin, uint32_t _version)
+    : label_hash{_label},
+      desc_hash{_desc},
+      origin_hash{_origin},
+      version{_version}
   {
-    return (const char*)(&value);
   }
+  uint32_t label_hash;
+  uint32_t desc_hash;
+  uint32_t origin_hash;
+  uint32_t version;
 
-  consteval operator o2::header::DataOrigin()
+  constexpr bool operator==(TableRef const& other) const noexcept
   {
-    return o2::header::DataOrigin{value};
+    return (this->label_hash == other.label_hash) &&
+           (this->desc_hash == other.desc_hash) &&
+           (this->origin_hash == other.origin_hash) &&
+           (this->version == other.version);
   }
 
-  consteval OriginEnc(OriginEnc const& other) = default;
-  consteval OriginEnc(OriginEnc&& other) noexcept = default;
-  consteval OriginEnc& operator=(OriginEnc const& other) = default;
-  consteval OriginEnc& operator=(OriginEnc&& other) noexcept = default;
-};
-} // namespace o2::framework
-
-template <>
-struct fmt::formatter<o2::framework::OriginEnc> {
-  char presentation = 's';
-  constexpr auto parse(format_parse_context& ctx)
+  constexpr bool descriptionCompatible(TableRef const& other) const noexcept
   {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it != end && (*it == 's')) {
-      presentation = *it++;
-    }
-
-    // Check if reached the end of the range:
-    if (it != end && *it != '}') {
-      throw format_error("invalid pick format");
-    }
-
-    // Return an iterator past the end of the parsed range:
-    return it;
+    return this->desc_hash == other.desc_hash;
   }
 
-  template <typename FormatContext>
-  auto format(o2::framework::OriginEnc const& origin, FormatContext& ctx)
+  constexpr bool descriptionCompatible(uint32_t _desc_hash) const noexcept
   {
-    return fmt::format_to(ctx.out(), "{}", (std::string_view)origin);
+    return this->desc_hash == _desc_hash;
   }
+
+  constexpr TableRef(TableRef const&) = default;
+  constexpr TableRef& operator=(TableRef const&) = default;
+  constexpr TableRef(TableRef&&) = default;
+  constexpr TableRef& operator=(TableRef&&) = default;
 };
 
-namespace o2::aod
+/// Helpers to manipulate TableRef arrays
+template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2>
+consteval auto merge()
 {
-DECLARE_SOA_METADATA();
+  constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
+  std::array<TableRef, N1 + N2 - duplicates> out;
+
+  auto pos = std::copy(ar1.begin(), ar1.end(), out.begin());
+  std::copy_if(ar2.begin(), ar2.end(), pos, [&](TableRef const& a) { return std::none_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
+  return out;
 }
 
-namespace o2::soa
+template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2, typename L>
+consteval auto merge_if(L l)
 {
-/// special case for the template with origin
-template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
-struct is_specialization_origin : std::false_type {
-};
+  constexpr const int to_remove = std::ranges::count_if(ar1.begin(), ar1.end(), [&](TableRef const& a) { return !l(a); });
+  constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }) || !l(a); });
+  std::array<TableRef, N1 + N2 - duplicates - to_remove> out;
 
-template <template <o2::framework::OriginEnc, typename...> class Ref, o2::framework::OriginEnc ORIGIN, typename... Args>
-struct is_specialization_origin<Ref<ORIGIN, Args...>, Ref> : std::true_type {
-};
+  auto pos = std::copy_if(ar1.begin(), ar1.end(), out.begin(), [&](TableRef const& a) { return l(a); });
+  std::copy_if(ar2.begin(), ar2.end(), pos, [&](TableRef const& a) { return std::none_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }) && l(a); });
+  return out;
+}
 
-template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
-inline constexpr bool is_specialization_origin_v = is_specialization_origin<T, Ref>::value;
+template <size_t N, std::array<TableRef, N> ar, typename L>
+consteval auto remove_if(L l)
+{
+  constexpr const int to_remove = std::ranges::count_if(ar.begin(), ar.end(), [&l](TableRef const& e) { return l(e); });
+  std::array<TableRef, N - to_remove> out;
+  std::copy_if(ar.begin(), ar.end(), out.begin(), [&l](TableRef const& e) { return !l(e); });
+  return out;
+}
 
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-struct is_base_of_template_origin_impl {
-  template <o2::framework::OriginEnc ORIGIN, typename... Ts>
-  static constexpr std::true_type test(const base<ORIGIN, Ts...>*);
-  static constexpr std::false_type test(...);
-  using type = decltype(test(std::declval<derived*>()));
-};
+template <size_t N1, size_t N2, std::array<TableRef, N1> ar1, std::array<TableRef, N2> ar2>
+consteval auto intersect()
+{
+  constexpr const int duplicates = std::ranges::count_if(ar2.begin(), ar2.end(), [&](TableRef const& a) { return std::any_of(ar1.begin(), ar1.end(), [&](TableRef const& e) { return e == a; }); });
+  std::array<TableRef, duplicates> out;
+  std::copy_if(ar1.begin(), ar1.end(), out.begin(), [](TableRef const& a) { return std::find(ar2.begin(), ar2.end(), a) != ar2.end(); });
+  return out;
+}
 
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-using is_base_of_template_origin = typename is_base_of_template_origin_impl<base, derived>::type;
+template <typename T, typename... Ts>
+consteval auto mergeOriginals()
+  requires(sizeof...(Ts) == 1)
+{
+  using T1 = framework::pack_head_t<framework::pack<Ts...>>;
+  return merge<T::originals.size(), T1::originals.size(), T::originals, T1::originals>();
+}
+
+template <typename T, typename... Ts>
+consteval auto mergeOriginals()
+  requires(sizeof...(Ts) > 1)
+{
+  constexpr auto tail = mergeOriginals<Ts...>();
+  return merge<T::originals.size(), tail.size(), T::originals, tail>();
+}
 
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-inline constexpr bool is_base_of_template_origin_v = is_base_of_template_origin<base, derived>::value;
+template <typename T, typename... Ts>
+  requires(sizeof...(Ts) == 1)
+consteval auto intersectOriginals()
+{
+  using T1 = framework::pack_head_t<framework::pack<Ts...>>;
+  return intersect<T::originals.size(), T1::originals.size(), T::originals, T1::originals>();
+}
 
+template <typename T, typename... Ts>
+  requires(sizeof...(Ts) > 1)
+consteval auto intersectOriginals()
+{
+  constexpr auto tail = intersectOriginals<Ts...>();
+  return intersect<T::originals.size(), tail.size(), T::originals, tail>();
+}
+} // namespace o2::soa
+
+namespace o2::soa
+{
 template <typename T>
-concept not_void = !std::same_as<T, void>;
+concept not_void = requires { !std::same_as<T, void>; };
 
-// column identification concepts
+/// column identification concepts
 template <typename C>
 concept is_persistent_column = requires(C c) { c.mColumnIterator; };
 
 template <typename C>
-using is_persistent_t = std::conditional_t<is_persistent_column<C>, std::true_type, std::false_type>;
+constexpr bool is_persistent_v = is_persistent_column<C>;
 
 template <typename C>
-static constexpr bool is_persistent_v = is_persistent_column<C>;
+using is_persistent_column_t = std::conditional_t<is_persistent_column<C>, std::true_type, std::false_type>;
 
 template <typename C>
-concept is_index_column = not_void<typename C::binding_t>;
+concept is_self_index_column = not_void<typename C::self_index_t> && std::same_as<typename C::self_index_t, std::true_type>;
 
 template <typename C>
-using is_external_index_t = typename std::conditional_t<is_index_column<C>, std::true_type, std::false_type>;
+concept is_index_column = !is_self_index_column<C> && (requires { &C::getId; } || requires { &C::getIds; });
 
 template <typename C>
-concept is_self_index_column = requires { typename C::self_index_t{}; };
+using is_external_index_t = typename std::conditional_t<is_index_column<C>, std::true_type, std::false_type>;
 
 template <typename C>
 using is_self_index_t = typename std::conditional_t<is_self_index_column<C>, std::true_type, std::false_type>;
+} // namespace o2::soa
+
+namespace o2::aod
+{
+/// Base type for table metadata
+template <typename D, typename... Cs>
+struct TableMetadata {
+  using columns = framework::pack<Cs...>;
+  using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, Cs...>;
+  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, Cs...>;
+  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, Cs...>;
+
+  template <typename Key, typename... PCs>
+  static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
+  {
+    return std::array<bool, sizeof...(PCs)>{[]() {
+      if constexpr (requires { PCs::index_targets.size(); }) {
+        return Key::template isIndexTargetOf<PCs::index_targets.size(), PCs::index_targets>();
+      } else {
+        return false;
+      }
+    }()...};
+  }
+
+  template <typename Key>
+  static consteval int getIndexPosToKey()
+  {
+    return getIndexPosToKey_impl<Key, framework::pack_size(persistent_columns_t{}), getMap<Key>(persistent_columns_t{})>();
+  }
+
+  template <typename Key, size_t N, std::array<bool, N> map>
+  static consteval int getIndexPosToKey_impl()
+  {
+    constexpr const auto pos = std::find(map.begin(), map.end(), true);
+    if constexpr (pos != map.end()) {
+      return std::distance(map.begin(), pos);
+    } else {
+      return -1;
+    }
+  }
+};
+
+template <typename D>
+struct MetadataTrait {
+  using metadata = void;
+};
+
+/// Special struc to map the string hash back to the string and wrap a string literal into the
+/// type signature
+template <uint32_t H>
+struct Hash {
+  static constexpr uint32_t hash = H;
+  static constexpr char const* const str{""};
+};
+
+/// Filter TableRef array for compatibility with Key table
+template <size_t N, std::array<soa::TableRef, N> ar, typename Key>
+consteval auto filterForKey()
+{
+  constexpr std::array<bool, N> test = []<size_t... Is>(std::index_sequence<Is...>) {
+    return std::array<bool, N>{(Key::template hasOriginal<ar[Is]>() || (o2::aod::MetadataTrait<o2::aod::Hash<ar[Is].desc_hash>>::metadata::template getIndexPosToKey<Key>() >= 0))...};
+  }(std::make_index_sequence<N>());
+  constexpr int correct = std::ranges::count(test.begin(), test.end(), true);
+  std::array<soa::TableRef, correct> out;
+  std::ranges::copy_if(ar.begin(), ar.end(), out.begin(), [&test](soa::TableRef const& r) { return test[std::distance(ar.begin(), std::find(ar.begin(), ar.end(), r))]; });
+  return out;
+}
+
+/// Pre-declare Hash specialization for a generic string
+#define O2HASH(_Str_)                              \
+  template <>                                      \
+  struct Hash<_Str_ ""_h> {                        \
+    static constexpr uint32_t hash = _Str_ ""_h;   \
+    static constexpr char const* const str{_Str_}; \
+  };
+
+/// Pre-declare Hash specialization for an origin string
+#define O2ORIGIN(_Str_)                                \
+  template <>                                          \
+  struct Hash<_Str_ ""_h> {                            \
+    static constexpr header::DataOrigin origin{_Str_}; \
+    static constexpr uint32_t hash = _Str_ ""_h;       \
+    static constexpr char const* const str{_Str_};     \
+  };
+
+/// Compile-time function to extract version from table signature string "DESC/#"
+static inline constexpr uint32_t version(const char* const str)
+{
+  if (str[0] == '\0') {
+    return 0;
+  }
+  size_t len = 0;
+  uint32_t res = 0;
+  while (str[len] != '/' && str[len] != '\0') {
+    ++len;
+  }
+  if (str[len - 1] == '\0') {
+    return -1;
+  }
+  for (auto i = len + 1; str[i] != '\0'; ++i) {
+    res = res * 10 + (int)(str[i] - '0');
+  }
+  return res;
+}
+
+/// Compile-time functions to extract description from table signature string "DESC/#"
+static inline constexpr std::string_view description_str(const char* const str)
+{
+  size_t len = 0;
+  while (len < 15 && str[len] != '/') {
+    ++len;
+  }
+  return std::string_view{str, len};
+}
 
+static inline constexpr header::DataDescription description(const char* const str)
+{
+  size_t len = 0;
+  while (len < 15 && str[len] != '/') {
+    ++len;
+  }
+  char out[16];
+  for (auto i = 0; i < 16; ++i) {
+    out[i] = 0;
+  }
+  std::memcpy(out, str, len);
+  return {out};
+}
+
+// Helpers to get strings from TableRef
+template <soa::TableRef R>
+consteval const char* label()
+{
+  return o2::aod::Hash<R.label_hash>::str;
+}
+
+template <soa::TableRef R>
+consteval const char* origin_str()
+{
+  return o2::aod::Hash<R.origin_hash>::str;
+}
+
+template <soa::TableRef R>
+consteval header::DataOrigin origin()
+{
+  return o2::aod::Hash<R.origin_hash>::origin;
+}
+
+template <soa::TableRef R>
+consteval const char* signature()
+{
+  return o2::aod::Hash<R.desc_hash>::str;
+}
+
+/// hash identification concepts
+template <typename T>
+concept is_aod_hash = requires(T t) { t.hash; t.str; };
+
+template <typename T>
+concept is_origin_hash = is_aod_hash<T> && requires(T t) { t.origin; };
+
+/// convert TableRef to a DPL source specification
+template <soa::TableRef R>
+static constexpr auto sourceSpec()
+{
+  return fmt::format("{}/{}/{}/{}", label<R>(), origin_str<R>(), description_str(signature<R>()), R.version);
+}
+} // namespace o2::aod
+
+namespace o2::soa
+{
+template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... Ts>
+class Table;
+
+/// Type-checking index column binding
 struct Binding {
   void const* ptr = nullptr;
   size_t hash = 0;
+  std::span<TableRef const> refs;
 
   template <typename T>
   void bind(T const* table)
   {
     ptr = table;
     hash = o2::framework::TypeIdHelpers::uniqueId<T>();
+    refs = std::span{T::originals};
   }
 
   template <typename T>
@@ -184,10 +395,6 @@ struct Binding {
   }
 };
 
-void accessingInvalidIndexFor(const char* getter);
-void dereferenceWithWrongType();
-void missingFilterDeclaration(int hash, int ai);
-
 template <typename... C>
 auto createFieldsFromColumns(framework::pack<C...>)
 {
@@ -196,23 +403,11 @@ auto createFieldsFromColumns(framework::pack<C...>)
 
 using SelectionVector = std::vector<int64_t>;
 
-template <typename T>
-inline constexpr bool is_index_column_v = is_index_column<T>;
-
-template <typename, typename = void>
-inline constexpr bool is_type_with_originals_v = false;
-
-template <typename T>
-inline constexpr bool is_type_with_originals_v<T, std::void_t<decltype(sizeof(typename T::originals))>> = true;
-
 template <typename T>
 concept has_parent_t = not_void<typename T::parent_t>;
 
-template <typename INHERIT>
-class TableMetadata;
-
 template <typename T>
-concept is_metadata = framework::base_of_template<TableMetadata, T>;
+concept is_metadata = framework::base_of_template<aod::TableMetadata, T>;
 
 template <typename T>
 concept is_metadata_trait = framework::specialization_of_template<aod::MetadataTrait, T>;
@@ -221,69 +416,26 @@ template <typename T>
 concept has_metadata = is_metadata_trait<T> && not_void<typename T::metadata>;
 
 template <typename T>
-concept has_sources = is_metadata<T> && not_void<typename T::sources>;
+concept has_extension = is_metadata<T> && not_void<typename T::extension_table_t>;
 
 template <typename T>
-concept is_spawnable_column = std::is_same_v<typename T::spawnable_t, std::true_type>;
+concept is_spawnable_column = std::same_as<typename T::spawnable_t, std::true_type>;
 
 template <typename B, typename E>
 struct EquivalentIndex {
   constexpr static bool value = false;
 };
 
+template <aod::is_aod_hash A, aod::is_aod_hash B>
+struct EquivalentIndexNG {
+  constexpr static bool value = false;
+};
+
 template <typename B, typename E>
 constexpr bool is_index_equivalent_v = EquivalentIndex<B, E>::value || EquivalentIndex<E, B>::value;
 
-template <typename T, typename TLambda>
-void call_if_has_originals(TLambda&& lambda)
-{
-  if constexpr (is_type_with_originals_v<T>) {
-    lambda(static_cast<T*>(nullptr));
-  }
-}
-
-template <typename T, typename TLambda>
-void call_if_has_not_originals(TLambda&& lambda)
-{
-  if constexpr (!is_type_with_originals_v<T>) {
-    lambda(static_cast<T*>(nullptr));
-  }
-}
-
-template <typename H, typename... T>
-consteval decltype(auto) make_originals_from_type()
-{
-  using decayed = std::decay_t<H>;
-  if constexpr (sizeof...(T) == 0) {
-    if constexpr (is_type_with_originals_v<decayed>) {
-      return typename decayed::originals{};
-    } else if constexpr (is_type_with_originals_v<typename decayed::table_t>) {
-      return typename decayed::table_t::originals{};
-    } else if constexpr (soa::has_parent_t<decayed>) {
-      return make_originals_from_type<typename decayed::parent_t>();
-    } else {
-      return framework::pack<decayed>{};
-    }
-  } else if constexpr (is_type_with_originals_v<decayed>) {
-    return framework::concatenate_pack(typename decayed::originals{}, make_originals_from_type<T...>());
-  } else if constexpr (is_type_with_originals_v<typename decayed::table_t>) {
-    return framework::concatenate_pack(typename decayed::table_t::originals{}, make_originals_from_type<T...>());
-  } else {
-    return framework::concatenate_pack(framework::pack<decayed>{}, make_originals_from_type<T...>());
-  }
-}
-
-template <typename... T>
-consteval decltype(auto) make_originals_from_type(framework::pack<T...> p)
-{
-  if constexpr (sizeof...(T) == 0) {
-    return framework::pack<>{};
-  } else {
-    return []<typename H, typename... Ta>(framework::pack<H, Ta...>) {
-      return make_originals_from_type<H, Ta...>();
-    }(p);
-  }
-}
+template <aod::is_aod_hash A, aod::is_aod_hash B>
+constexpr bool is_ng_index_equivalent_v = EquivalentIndexNG<A, B>::value || EquivalentIndexNG<B, A>::value;
 
 /// Policy class for columns which are chunked. This
 /// will make the compiler take the most generic (and
@@ -324,7 +476,7 @@ using unwrap_t = typename unwrap<T>::type;
 template <typename T, typename ChunkingPolicy = Chunked>
 class ColumnIterator : ChunkingPolicy
 {
-  static constexpr char SCALE_FACTOR = std::is_same_v<std::decay_t<T>, bool> ? 3 : 0;
+  static constexpr char SCALE_FACTOR = std::same_as<std::decay_t<T>, bool> ? 3 : 0;
 
  public:
   /// Constructor of the column iterator. Notice how it takes a pointer
@@ -399,53 +551,33 @@ class ColumnIterator : ChunkingPolicy
   }
 
   decltype(auto) operator*() const
+    requires std::same_as<bool, std::decay_t<T>>
   {
-    if constexpr (ChunkingPolicy::chunked) {
-      if constexpr (std::is_same_v<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())) {
-          nextChunk();
-        }
-      } else {
-        if (O2_BUILTIN_UNLIKELY(((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) >= mLast))) {
-          nextChunk();
-        }
-      }
-    }
-    if constexpr (std::is_same_v<bool, std::decay_t<T>>) {
-      // FIXME: check if shifting the masked bit to the first position is better than != 0
-      return (*(mCurrent - (mOffset >> SCALE_FACTOR) + ((*mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;
-    } else if constexpr (std::is_same_v<arrow_array_for_t<T>, arrow::ListArray>) {
-      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);
-      return gsl::span{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
-    } else {
-      return *(mCurrent + (*mCurrentPos >> SCALE_FACTOR));
-    }
+    checkSkipChunk();
+    return (*(mCurrent - (mOffset >> SCALE_FACTOR) + ((*mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;
   }
 
-  // Move to the chunk which containts element pos
-  ColumnIterator<T>& moveToPos()
+  decltype(auto) operator*() const
+    requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
-    // If we get outside range of the current chunk, go to the next.
-    if constexpr (ChunkingPolicy::chunked) {
-      while (O2_BUILTIN_UNLIKELY((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) >= mLast)) {
-        nextChunk();
-      }
-    }
-    return *this;
+    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);
+    return gsl::span{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
+  }
+
+  decltype(auto) operator*() const
+    requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
+  {
+    checkSkipChunk();
+    return *(mCurrent + (*mCurrentPos >> SCALE_FACTOR));
   }
 
   // Move to the chunk which containts element pos
-  ColumnIterator<T>& checkNextChunk()
+  ColumnIterator<T>& moveToPos()
   {
-    if constexpr (ChunkingPolicy::chunked) {
-      if (O2_BUILTIN_LIKELY((mCurrent + (*mCurrentPos >> SCALE_FACTOR)) <= mLast)) {
-        return *this;
-      }
-      nextChunk();
-    }
+    checkSkipChunk();
     return *this;
   }
 
@@ -458,21 +590,53 @@ class ColumnIterator : ChunkingPolicy
   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())) {
+      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))) {
+      nextChunk();
+    }
+  }
+
+  void checkSkipChunk() const
+    requires(ChunkingPolicy::chunked == false)
+  {
+  }
   /// get pointer to mCurrentChunk chunk
   auto getCurrentArray() const
+    requires(std::same_as<arrow_array_for_t<T>, arrow::FixedSizeListArray>)
   {
     std::shared_ptr<arrow::Array> chunkToUse = mColumn->chunk(mCurrentChunk);
     mOffset = chunkToUse->offset();
-    if constexpr (std::is_same_v<arrow_array_for_t<T>, arrow::FixedSizeListArray>) {
-      chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
-      return std::static_pointer_cast<arrow_array_for_t<value_for_t<T>>>(chunkToUse);
-    } else if constexpr (std::is_same_v<arrow_array_for_t<T>, arrow::ListArray>) {
-      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);
-    } else {
-      return std::static_pointer_cast<arrow_array_for_t<T>>(chunkToUse);
-    }
+    chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
+    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::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);
   }
 };
 
@@ -491,7 +655,6 @@ struct Column {
   Column(Column&&) = default;
   Column& operator=(Column&&) = default;
 
-  using persistent = std::true_type;
   using type = T;
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
   ColumnIterator<T> const& getIterator() const
@@ -515,7 +678,6 @@ template <typename F, typename INHERIT>
 struct DynamicColumn {
   using inherited_t = INHERIT;
 
-  using persistent = std::false_type;
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
 };
 
@@ -523,7 +685,6 @@ template <typename INHERIT>
 struct IndexColumn {
   using inherited_t = INHERIT;
 
-  using persistent = std::false_type;
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
 };
 
@@ -531,7 +692,6 @@ template <typename INHERIT>
 struct MarkerColumn {
   using inherited_t = INHERIT;
 
-  using persistent = std::false_type;
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
 };
 
@@ -632,17 +792,19 @@ struct Index : o2::soa::IndexColumn<Index<START, END>> {
   std::tuple<uint64_t const*> rowOffsets;
 };
 
-template <typename T>
-concept is_dynamic_column = framework::is_base_of_template_v<soa::DynamicColumn, T>;
+template <typename D>
+concept is_indexing_column = requires {
+  []<int64_t S, int64_t E>(o2::soa::Index<S, E>*) {}(std::declval<D*>());
+};
 
 template <typename T>
-using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
+concept is_dynamic_column = framework::base_of_template<soa::DynamicColumn, T>;
 
 template <typename T>
-concept is_indexing_column = framework::is_base_of_template_v<soa::IndexColumn, T>;
+using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
 
 template <typename T>
-concept is_column = framework::is_base_of_template_v<soa::Column, T> || is_dynamic_column<T> || is_indexing_column<T> || framework::is_base_of_template_v<soa::MarkerColumn, T>;
+concept is_column = framework::base_of_template<soa::Column, T> || is_dynamic_column<T> || is_indexing_column<T> || framework::base_of_template<soa::MarkerColumn, T>;
 
 template <typename T>
 using is_indexing_t = std::conditional_t<is_indexing_column<T>, std::true_type, std::false_type>;
@@ -838,11 +1000,14 @@ struct DefaultIndexPolicy : IndexPolicyBase {
   int64_t mMaxRow = 0;
 };
 
-template <o2::framework::OriginEnc ORIGIN, typename... C>
+// template <OriginEnc ORIGIN, typename... C>
+// class Table;
+
+template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... T>
 class Table;
 
 template <typename T>
-concept is_table = soa::is_specialization_origin_v<T, soa::Table> || soa::is_base_of_template_origin_v<soa::Table, T>;
+concept is_table = framework::specialization_of_template<soa::Table, T> || framework::base_of_template<soa::Table, T>;
 
 /// Similar to a pair but not a pair, to avoid
 /// exposing the second type everywhere.
@@ -857,19 +1022,20 @@ concept can_bind = requires(T&& t) {
   { t.B::mColumnIterator };
 };
 
-template <o2::framework::OriginEnc ORIGIN, typename IP, typename... C>
-struct RowViewCore : public IP, C... {
+template <typename D, typename O, typename IP, typename... C>
+struct TableIterator : IP, C... {
  public:
+  using self_t = TableIterator<D, O, IP, C...>;
   using policy_t = IP;
-  using table_t = o2::soa::Table<ORIGIN, C...>;
   using all_columns = framework::pack<C...>;
-  using persistent_columns_t = framework::selected_pack<is_persistent_t, C...>;
-  using index_columns_t = framework::selected_pack<is_indexing_t, C...>;
-  constexpr inline static bool has_index_v = framework::pack_size(index_columns_t{}) > 0;
-  using external_index_columns_t = framework::selected_pack<is_external_index_t, C...>;
-  using internal_index_columns_t = framework::selected_pack<is_self_index_t, C...>;
-
-  RowViewCore(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
+  using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
+  using indexing_columns_t = framework::selected_pack<is_indexing_t, C...>;
+  constexpr inline static bool has_index_v = framework::pack_size(indexing_columns_t{}) > 0;
+  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, C...>;
+  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, C...>;
+  using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) -> framework::pack<typename Cs::binding_t...> {}(external_index_columns_t{})); // decltype(extractBindings(external_index_columns_t{}));
+
+  TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     : IP{policy},
       C(columnData[framework::has_type_at_v<C>(all_columns{})])...
   {
@@ -883,15 +1049,15 @@ struct RowViewCore : public IP, C... {
     }
   }
 
-  RowViewCore() = default;
-  RowViewCore(RowViewCore<ORIGIN, IP, C...> const& other)
+  TableIterator() = default;
+  TableIterator(self_t const& other)
     : IP{static_cast<IP const&>(other)},
       C(static_cast<C const&>(other))...
   {
     bind();
   }
 
-  RowViewCore& operator=(RowViewCore other)
+  TableIterator& operator=(TableIterator other)
   {
     IP::operator=(static_cast<IP const&>(other));
     (void(static_cast<C&>(*this) = static_cast<C>(other)), ...);
@@ -899,53 +1065,54 @@ struct RowViewCore : public IP, C... {
     return *this;
   }
 
-  RowViewCore(RowViewCore<ORIGIN, FilteredIndexPolicy, C...> const& other) requires std::is_same_v<IP, DefaultIndexPolicy>
+  TableIterator(TableIterator<D, O, FilteredIndexPolicy, C...> const& other)
+    requires std::same_as<IP, DefaultIndexPolicy>
     : IP{static_cast<IP const&>(other)},
       C(static_cast<C const&>(other))...
   {
     bind();
   }
 
-  RowViewCore& operator++()
+  TableIterator& operator++()
   {
     this->moveByIndex(1);
     return *this;
   }
 
-  RowViewCore operator++(int)
+  TableIterator operator++(int)
   {
-    RowViewCore<ORIGIN, IP, C...> copy = *this;
+    self_t copy = *this;
     this->operator++();
     return copy;
   }
 
-  RowViewCore& operator--()
+  TableIterator& operator--()
   {
     this->moveByIndex(-1);
     return *this;
   }
 
-  RowViewCore operator--(int)
+  TableIterator operator--(int)
   {
-    RowViewCore<ORIGIN, IP, C...> copy = *this;
+    self_t copy = *this;
     this->operator--();
     return copy;
   }
 
   /// Allow incrementing by more than one the iterator
-  RowViewCore operator+(int64_t inc) const
+  TableIterator operator+(int64_t inc) const
   {
-    RowViewCore copy = *this;
+    TableIterator copy = *this;
     copy.moveByIndex(inc);
     return copy;
   }
 
-  RowViewCore operator-(int64_t dec) const
+  TableIterator operator-(int64_t dec) const
   {
     return operator+(-dec);
   }
 
-  RowViewCore const& operator*() const
+  TableIterator const& operator*() const
   {
     return *this;
   }
@@ -1005,14 +1172,6 @@ struct RowViewCore : public IP, C... {
   }
 
  private:
-  /// Helper to move to the correct chunk, if needed.
-  /// FIXME: not needed?
-  template <typename... PC>
-  void checkNextChunk(framework::pack<PC...>)
-  {
-    (PC::mColumnIterator.checkNextChunk(), ...);
-  }
-
   /// Helper to move at the end of columns which actually have an iterator.
   template <typename... PC>
   void doMoveToEnd(framework::pack<PC...>)
@@ -1026,14 +1185,10 @@ struct RowViewCore : public IP, C... {
   {
     using namespace o2::soa;
     auto f = framework::overloaded{
-      [this]<typename T>(T*) -> void
-        requires is_persistent_column<T>
-                 { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
-                 [this]<typename T>(T*) -> void
-                   requires is_dynamic_column<T>
-      { bindDynamicColumn<T>(typename T::bindings_t{}); },
+      [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
+      [this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },
       [this]<typename T>(T*) -> void {},
-      };
+    };
     (f(static_cast<C*>(nullptr)), ...);
     if constexpr (has_index_v) {
       this->setIndices(this->getIndices());
@@ -1053,12 +1208,12 @@ struct RowViewCore : public IP, C... {
   // error if constructor for the table or any other thing involving a missing
   // binding is preinstanciated.
   template <typename B>
-    requires(can_bind<typename table_t::iterator, B>)
+    requires(can_bind<self_t, B>)
   decltype(auto) getDynamicBinding()
   {
-    static_assert(std::is_same_v<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
+    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>
@@ -1068,111 +1223,84 @@ struct RowViewCore : public IP, C... {
   }
 };
 
-template <typename T>
-concept is_iterator = soa::is_base_of_template_origin_v<RowViewCore, T> || soa::is_specialization_origin_v<T, RowViewCore>;
-
-template <typename, typename = void>
-constexpr bool is_type_with_policy_v = false;
-
-template <typename T>
-constexpr bool is_type_with_policy_v<T, std::void_t<decltype(sizeof(typename T::policy_t))>> = true;
-
 struct ArrowHelpers {
   static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
   static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
 };
 
+//! Helper to check if a type T is an iterator
 template <typename T>
-concept with_base_table = not_void<typename aod::MetadataTrait<T>::metadata::base_table_t>;
+concept is_iterator = framework::base_of_template<TableIterator, T> || framework::specialization_of_template<TableIterator, T>;
 
-template <typename... T>
-using originals_pack_t = decltype(make_originals_from_type(framework::pack<T...>{}));
+template <typename T>
+concept with_originals = requires {
+  T::originals.size();
+};
 
-template <typename T, typename... Os>
-constexpr bool are_bindings_compatible_v(framework::pack<Os...>&&)
+template <typename T>
+concept with_sources = requires {
+  T::sources.size();
+};
+
+template <typename T>
+concept with_base_table = not_void<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>;
+
+template <size_t N1, std::array<TableRef, N1> os1, size_t N2, std::array<TableRef, N2> os2>
+consteval bool is_compatible()
 {
-  if constexpr (is_type_with_originals_v<T>) {
-    return (are_bindings_compatible_v<Os>(originals_pack_t<T>{}) || ...);
-  } else {
-    return ((std::is_same_v<T, Os> || is_index_equivalent_v<T, Os>) || ...);
-  }
+  return []<size_t... Is>(std::index_sequence<Is...>) {
+    return ([]<size_t... Ks>(std::index_sequence<Ks...>) {
+      constexpr auto h = os1[Is].desc_hash;
+      using H = o2::aod::Hash<h>;
+      return (((h == os2[Ks].desc_hash) || is_ng_index_equivalent_v<H, o2::aod::Hash<os2[Ks].desc_hash>>) || ...);
+    }(std::make_index_sequence<N2>()) ||
+            ...);
+  }(std::make_index_sequence<N1>());
 }
 
-template <typename T, typename B>
-constexpr bool is_binding_compatible_v()
+template <with_originals T, with_originals B>
+consteval bool is_binding_compatible_v()
 {
-  return are_bindings_compatible_v<T>(originals_pack_t<B>{});
+  return is_compatible<T::originals.size(), T::originals, B::originals.size(), B::originals>();
 }
 
 template <typename T, typename B>
-struct is_binding_compatible : std::conditional_t<is_binding_compatible_v<T, typename B::binding_t>(), std::true_type, std::false_type> {
-};
+using is_binding_compatible = std::conditional_t<is_binding_compatible_v<T, typename B::binding_t>(), std::true_type, std::false_type>;
 
-template <o2::framework::OriginEnc ORIGIN, typename Key, typename H, typename... Ts>
+template <typename L, typename D, typename O, typename Key, typename H, typename... Ts>
 struct IndexTable;
 
 template <typename T>
-concept is_index_table = soa::is_specialization_origin_v<T, o2::soa::IndexTable>;
+concept is_index_table = framework::specialization_of_template<o2::soa::IndexTable, T>;
 
 template <soa::is_table T>
-  requires(!soa::is_index_table<T>)
-static constexpr std::string getLabelFromType()
+static constexpr std::string getLabelForTable()
 {
-  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
-    using TT = typename framework::pack_head_t<typename std::decay_t<T>::originals>;
-    if constexpr (soa::with_base_table<typename aod::MetadataTrait<TT>::metadata>) {
-      using TTT = typename aod::MetadataTrait<TT>::metadata::base_table_t;
-      return getLabelFromType<TTT>();
-    } else {
-      using groupingMetadata = typename aod::MetadataTrait<TT>::metadata;
-      return std::string{groupingMetadata::tableLabel()};
-    }
-  } else {
-    if constexpr (soa::with_base_table<typename aod::MetadataTrait<T>::metadata>) {
-      using TT = typename aod::MetadataTrait<T>::metadata::base_table_t;
-      return getLabelFromType<TT>();
-    } else {
-      using groupingMetadata = typename aod::MetadataTrait<std::decay_t<T>>::metadata;
-      return std::string{groupingMetadata::tableLabel()};
-    }
-  }
+  return std::string{aod::label<std::decay_t<T>::originals[0]>()};
 }
 
-template <soa::is_index_table T>
+template <soa::is_table T>
+  requires(!(soa::is_index_table<T> || soa::with_base_table<T>))
 static constexpr std::string getLabelFromType()
 {
-  using TT = typename std::decay_t<T>::first_t;
-  if constexpr (soa::is_type_with_originals_v<std::decay_t<TT>>) {
-    using O = typename framework::pack_head_t<typename std::decay_t<TT>::originals>;
-    using groupingMetadata = typename aod::MetadataTrait<O>::metadata;
-    return std::string{groupingMetadata::tableLabel()};
-  } else {
-    using groupingMetadata = typename aod::MetadataTrait<TT>::metadata;
-    return std::string{groupingMetadata::tableLabel()};
-  }
+  return getLabelForTable<T>();
 }
 
 template <soa::is_iterator T>
 static constexpr std::string getLabelFromType()
 {
-  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
-    using TT = typename framework::pack_head_t<typename std::decay_t<T>::originals>;
-    if constexpr (soa::with_base_table<typename aod::MetadataTrait<TT>::metadata>) {
-      using TTT = typename aod::MetadataTrait<TT>::metadata::base_table_t;
-      return getLabelFromType<TTT>();
-    } else {
-      using groupingMetadata = typename aod::MetadataTrait<TT>::metadata;
-      return std::string{groupingMetadata::tableLabel()};
-    }
-  } else {
-    if constexpr (soa::with_base_table<typename aod::MetadataTrait<T>::metadata>) {
-      using TT = typename aod::MetadataTrait<T>::metadata::base_table_t;
-      return getLabelFromType<TT>();
-    } else {
-      using groupingMetadata = typename aod::MetadataTrait<std::decay_t<T>>::metadata;
-      return std::string{groupingMetadata::tableLabel()};
-    }
-  }
+  return getLabelForTable<typename std::decay_t<T>::parent_t>();
+}
+
+template <soa::is_index_table T>
+static constexpr std::string getLabelFromType()
+{
+  return getLabelForTable<typename std::decay_t<T>::first_t>();
+}
+template <soa::with_base_table T>
+static constexpr std::string getLabelFromType()
+{
+  return getLabelForTable<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>();
 }
 
 template <typename... C>
@@ -1181,10 +1309,10 @@ static constexpr auto hasColumnForKey(framework::pack<C...>, std::string const&
   return ((C::inherited_t::mLabel == key) || ...);
 }
 
-template <typename T>
+template <TableRef ref>
 static constexpr std::pair<bool, std::string> hasKey(std::string const& key)
 {
-  return {hasColumnForKey(typename T::persistent_columns_t{}, key), getLabelFromType<T>()};
+  return {hasColumnForKey(typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{}, key), aod::label<ref>()};
 }
 
 template <typename... C>
@@ -1196,21 +1324,22 @@ static constexpr auto haveKey(framework::pack<C...>, std::string const& key)
 void notFoundColumn(const char* label, const char* key);
 void missingOptionalPreslice(const char* label, const char* key);
 
-template <typename T, bool OPT = false>
+template <with_originals T, bool OPT = false>
 static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 {
-  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
-    using Os = typename std::decay_t<T>::originals;
-    auto locate = haveKey(Os{}, key);
+  if constexpr (T::originals.size() == 1) {
+    auto locate = hasKey<T::originals[0]>(key);
+    if (locate.first) {
+      return locate.second;
+    }
+  } else {
+    auto locate = [&]<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{hasKey<T::originals[Is]>(key)...};
+    }(std::make_index_sequence<T::originals.size()>{});
     auto it = std::find_if(locate.begin(), locate.end(), [](auto const& x) { return x.first; });
     if (it != locate.end()) {
       return it->second;
     }
-  } else {
-    auto locate = hasKey<std::decay_t<T>>(key);
-    if (locate.first) {
-      return locate.second;
-    }
   }
   if constexpr (!OPT) {
     notFoundColumn(getLabelFromType<std::decay_t<T>>().data(), key.data());
@@ -1323,34 +1452,34 @@ using PresliceOptional = PresliceBase<T, true, true>;
 namespace o2::soa
 {
 template <typename T>
-using is_soa_table_t = typename soa::is_specialization_origin<T, soa::Table>;
-
+class FilteredBase;
 template <typename T>
-inline constexpr bool is_soa_table_like_v = soa::is_base_of_template_origin_v<soa::Table, T>;
+class Filtered;
 
 template <typename T>
 class FilteredBase;
 template <typename T>
 class Filtered;
 
-template <typename T>
-inline constexpr bool is_soa_filtered_v = framework::is_base_of_template_v<soa::FilteredBase, T>;
-
 template <typename T>
 concept has_filtered_policy = not_void<typename T::policy_t> && std::same_as<typename T::policy_t, soa::FilteredIndexPolicy>;
 
 template <typename T>
-concept is_filtered_table = framework::is_base_of_template_v<soa::FilteredBase, T>;
+concept is_filtered_iterator = is_iterator<T> && has_filtered_policy<T>;
 
 template <typename T>
-concept is_not_filtered_table = is_table<T> && !is_filtered_table<T>;
+concept is_filtered_table = framework::base_of_template<soa::FilteredBase, T>;
 
+// FIXME: compatbility declaration to be removed
 template <typename T>
-concept is_filtered_iterator = is_iterator<T> && has_filtered_policy<T>;
+constexpr bool is_soa_filtered_v = is_filtered_table<T>;
 
 template <typename T>
 concept is_filtered = is_filtered_table<T> || is_filtered_iterator<T>;
 
+template <typename T>
+concept is_not_filtered_table = is_table<T> && !is_filtered_table<T>;
+
 /// Helper function to extract bound indices
 template <typename... Is>
 static consteval auto extractBindings(framework::pack<Is...>)
@@ -1474,128 +1603,212 @@ auto doFilteredSliceByCached(T const* table, framework::expressions::BindingNode
 template <typename T>
 auto doSliceByCachedUnsorted(T const* table, framework::expressions::BindingNode const& node, int value, o2::framework::SliceCache& cache)
 {
-  auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
-  if constexpr (soa::is_filtered_table<T>) {
-    auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
-    t.intersectWithSelection(table->getSelectedRows());
-    table->copyIndexBindings(t);
-    return t;
-  } else {
-    auto t = Filtered<T>({table->asArrowTable()}, localCache.getSliceFor(value));
-    table->copyIndexBindings(t);
-    return t;
-  }
+  auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
+  if constexpr (soa::is_filtered_table<T>) {
+    auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
+    t.intersectWithSelection(table->getSelectedRows());
+    table->copyIndexBindings(t);
+    return t;
+  } else {
+    auto t = Filtered<T>({table->asArrowTable()}, localCache.getSliceFor(value));
+    table->copyIndexBindings(t);
+    return t;
+  }
+}
+
+template <with_originals T>
+auto select(T const& t, framework::expressions::Filter const& f)
+{
+  return Filtered<T>({t.asArrowTable()}, selectionToVector(framework::expressions::createSelection(t.asArrowTable(), f)));
+}
+
+arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, const char* label);
+
+template <typename D, typename O, typename IP, typename... C>
+consteval auto base_iter(framework::pack<C...>&&) -> TableIterator<D, O, IP, C...>
+{
+}
+
+template <TableRef ref, typename... Ts>
+  requires((sizeof...(Ts) > 0) && (soa::is_column<Ts> && ...))
+consteval auto getColumns()
+{
+  return framework::pack<Ts...>{};
+}
+
+template <TableRef ref, typename... Ts>
+  requires((sizeof...(Ts) > 0) && !(soa::is_column<Ts> || ...) && (ref.origin_hash == "CONC"_h))
+consteval auto getColumns()
+{
+  return framework::full_intersected_pack_t<typename Ts::columns_t...>{};
+}
+
+template <TableRef ref, typename... Ts>
+  requires((sizeof...(Ts) > 0) && !(soa::is_column<Ts> || ...) && (ref.origin_hash != "CONC"_h))
+consteval auto getColumns()
+{
+  return framework::concatenated_pack_unique_t<typename Ts::columns_t...>{};
+}
+
+template <TableRef ref, typename... Ts>
+  requires(sizeof...(Ts) == 0 && soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>>)
+consteval auto getColumns()
+{
+  return typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{};
 }
 
-template <typename T>
-auto select(T const& t, framework::expressions::Filter const& f)
+template <TableRef ref, typename... Ts>
+  requires((sizeof...(Ts) == 0) || (o2::soa::is_column<Ts> && ...))
+consteval auto computeOriginals()
 {
-  return Filtered<T>({t.asArrowTable()}, selectionToVector(framework::expressions::createSelection(t.asArrowTable(), f)));
+  return std::array<TableRef, 1>{ref};
 }
 
-arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, const char* label);
+template <TableRef ref, typename... Ts>
+  requires((sizeof...(Ts) > 0) && (!o2::soa::is_column<Ts> || ...))
+consteval auto computeOriginals()
+{
+  return o2::soa::mergeOriginals<Ts...>();
+}
 
 /// A Table class which observes an arrow::Table and provides
 /// It is templated on a set of Column / DynamicColumn types.
-template <o2::framework::OriginEnc ORIGIN, typename... C>
+template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... Ts>
 class Table
 {
  public:
-  static constexpr o2::framework::OriginEnc mOrigin{ORIGIN};
-  using self_t = Table<ORIGIN, C...>;
-  using table_t = Table<ORIGIN, C...>;
-  using columns = framework::pack<C...>;
-  using column_types = framework::pack<typename C::type...>;
-  using persistent_columns_t = framework::selected_pack<is_persistent_t, C...>;
-  using external_index_columns_t = framework::selected_pack<is_external_index_t, C...>;
-  using internal_index_columns_t = framework::selected_pack<is_self_index_t, C...>;
+  static constexpr const auto ref = TableRef{L::hash, D::hash, O::hash, o2::aod::version(D::str)};
+  using self_t = Table<L, D, O, Ts...>;
+  using table_t = self_t;
 
-  static constexpr auto hashes()
+  static constexpr const auto originals = computeOriginals<ref, Ts...>();
+
+  template <size_t N, std::array<TableRef, N> bindings>
+    requires(ref.origin_hash == "CONC"_h)
+  static consteval auto isIndexTargetOf()
   {
-    return std::set{{o2::framework::TypeIdHelpers::uniqueId<C>()...}};
+    return false;
   }
 
-  template <typename IP, typename Parent, typename... T>
-  struct RowViewBase : public RowViewCore<ORIGIN, IP, C...> {
+  template <size_t N, std::array<TableRef, N> bindings>
+    requires(ref.origin_hash == "JOIN"_h)
+  static consteval auto isIndexTargetOf()
+  {
+    return std::find_if(self_t::originals.begin(), self_t::originals.end(),
+                        [](TableRef const& r) {
+                          return std::find(bindings.begin(), bindings.end(), r) != bindings.end();
+                        }) != self_t::originals.end();
+  }
 
-    using external_index_columns_t = framework::selected_pack<is_external_index_t, C...>;
-    using bindings_pack_t = decltype(extractBindings(external_index_columns_t{}));
-    using parent_t = Parent;
-    using originals = originals_pack_t<T...>;
+  template <size_t N, std::array<TableRef, N> bindings>
+    requires(!(ref.origin_hash == "CONC"_h || ref.origin_hash == "JOIN"_h))
+  static consteval auto isIndexTargetOf()
+  {
+    return std::find(bindings.begin(), bindings.end(), self_t::ref) != bindings.end();
+  }
+
+  template <TableRef r>
+  static consteval bool hasOriginal()
+  {
+    return std::find_if(originals.begin(), originals.end(), [](TableRef const& o) { return o.desc_hash == r.desc_hash; }) != originals.end();
+  }
+
+  using columns_t = decltype(getColumns<ref, Ts...>());
+
+  using persistent_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_persistent_column_t, C...> {}(columns_t{}));
+  using column_types = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::type...> {}(persistent_columns_t{}));
+
+  using external_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_external_index_t, C...> {}(columns_t{}));
+  using internal_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_self_index_t, C...> {}(columns_t{}));
+  template <typename IP>
+  using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
+
+  template <typename IP, typename Parent, typename... T>
+  struct TableIteratorBase : base_iterator<IP> {
+    using columns_t = typename Parent::columns_t;
+    using external_index_columns_t = typename Parent::external_index_columns_t;
+    using bindings_pack_t = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::binding_t...> {}(external_index_columns_t{}));
+    static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
     using policy_t = IP;
+    using parent_t = Parent;
 
-    RowViewBase() = default;
+    TableIteratorBase() = default;
 
-    RowViewBase(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
-      : RowViewCore<ORIGIN, IP, C...>(columnData, std::forward<decltype(policy)>(policy))
+    TableIteratorBase(arrow::ChunkedArray* columnData[framework::pack_size(columns_t{})], IP&& policy)
+      : base_iterator<IP>(columnData, std::forward<decltype(policy)>(policy))
     {
     }
 
-    template <typename P, typename... O>
-    RowViewBase& operator=(RowViewBase<IP, P, O...> other) requires std::is_same_v<typename P::table_t, typename Parent::table_t>
+    template <typename P, typename... Os>
+    TableIteratorBase& operator=(TableIteratorBase<IP, P, Os...> other)
+      requires(P::ref::signature == Parent::ref::signature)
     {
-      static_cast<RowViewCore<ORIGIN, IP, C...>&>(*this) = static_cast<RowViewCore<ORIGIN, IP, C...>>(other);
+      static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<IP>>(other);
       return *this;
     }
 
     template <typename P>
-    RowViewBase& operator=(RowViewBase<IP, P, T...> other)
+    TableIteratorBase& operator=(TableIteratorBase<IP, P, T...> other)
     {
-      static_cast<RowViewCore<ORIGIN, IP, C...>&>(*this) = static_cast<RowViewCore<ORIGIN, IP, C...>>(other);
+      static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<IP>>(other);
       return *this;
     }
 
     template <typename P>
-    RowViewBase& operator=(RowViewBase<FilteredIndexPolicy, P, T...> other) requires std::is_same_v<IP, DefaultIndexPolicy>
+    TableIteratorBase& operator=(TableIteratorBase<FilteredIndexPolicy, P, T...> other)
+      requires std::same_as<IP, DefaultIndexPolicy>
     {
-      static_cast<RowViewCore<ORIGIN, IP, C...>&>(*this) = static_cast<RowViewCore<ORIGIN, FilteredIndexPolicy, C...>>(other);
+      static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<FilteredIndexPolicy>>(other);
       return *this;
     }
 
-    template <typename P, typename... O>
-    RowViewBase(RowViewBase<IP, P, O...> const& other) requires std::is_same_v<typename P::table_t, typename Parent::table_t>
+    template <typename P, typename... Os>
+    TableIteratorBase(TableIteratorBase<IP, P, Os...> const& other)
+      requires(P::ref::signature == Parent::ref::signature)
     {
       *this = other;
     }
 
-    template <typename P, typename... O>
-    RowViewBase(RowViewBase<IP, P, O...>&& other) noexcept requires std::is_same_v<typename P::table_t, typename Parent::table_t>
+    template <typename P, typename... Os>
+    TableIteratorBase(TableIteratorBase<IP, P, Os...>&& other) noexcept
+      requires(P::ref::signature == Parent::ref::signature)
     {
       *this = other;
     }
 
     template <typename P>
-    RowViewBase(RowViewBase<IP, P, T...> const& other)
+    TableIteratorBase(TableIteratorBase<IP, P, T...> const& other)
     {
       *this = other;
     }
 
     template <typename P>
-    RowViewBase(RowViewBase<IP, P, T...>&& other) noexcept
+    TableIteratorBase(TableIteratorBase<IP, P, T...>&& other) noexcept
     {
       *this = other;
     }
 
     template <typename P>
-    RowViewBase(RowViewBase<FilteredIndexPolicy, P, T...> other) requires std::is_same_v<IP, DefaultIndexPolicy>
+    TableIteratorBase(TableIteratorBase<FilteredIndexPolicy, P, T...> other)
+      requires std::same_as<IP, DefaultIndexPolicy>
     {
       *this = other;
     }
 
-    RowViewBase& operator=(RowViewSentinel const& other)
+    TableIteratorBase& operator=(RowViewSentinel const& other)
     {
       this->mRowIndex = other.index;
       return *this;
     }
-
     template <typename P>
-    void matchTo(RowViewBase<IP, P, T...> const& other)
+    void matchTo(TableIteratorBase<IP, P, T...> const& other)
     {
       this->mRowIndex = other.mRowIndex;
     }
 
-    template <typename P, typename... O>
-    void matchTo(RowViewBase<IP, P, O...> const& other) requires std::is_same_v<typename P::table_t, typename Parent::table_t>
+    template <typename P, typename... Os>
+    void matchTo(TableIteratorBase<IP, P, Os...> const& other)
+      requires std::same_as<typename P::table_t, typename Parent::table_t>
     {
       this->mRowIndex = other.mRowIndex;
     }
@@ -1607,7 +1820,7 @@ class Table
       if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
         constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
         return framework::pack_element_t<idx, external_index_columns_t>::getId();
-      } else if constexpr (std::is_same_v<decayed, Parent>) { // self index
+      } else if constexpr (std::same_as<decayed, Parent>) { // self index
         return this->globalIndex();
       } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
         return this->globalIndex();
@@ -1628,51 +1841,71 @@ class Table
     auto getValue() const
     {
       using COL = std::decay_t<CC>;
-      static_assert(is_dynamic_t<COL>() || is_persistent_v<COL>, "Should be persistent or dynamic column with no argument that has a return type convertable to float");
+      static_assert(is_dynamic_t<COL>() || soa::is_persistent_column<COL>, "Should be persistent or dynamic column with no argument that has a return type convertable to float");
       return static_cast<B>(static_cast<COL>(*this).get());
     }
 
     template <typename B, typename... CCs>
     std::array<B, sizeof...(CCs)> getValues() const
     {
-      static_assert(std::is_same_v<B, float> || std::is_same_v<B, double>, "The common return type should be float or double");
+      static_assert(std::same_as<B, float> || std::same_as<B, double>, "The common return type should be float or double");
       return {getValue<B, CCs>()...};
     }
 
     using IP::size;
 
-    using RowViewCore<ORIGIN, IP, C...>::operator++;
+    using base_iterator<IP>::operator++;
 
     /// Allow incrementing by more than one the iterator
-    RowViewBase operator+(int64_t inc) const
+    TableIteratorBase operator+(int64_t inc) const
     {
-      RowViewBase copy = *this;
+      TableIteratorBase copy = *this;
       copy.moveByIndex(inc);
       return copy;
     }
 
-    RowViewBase operator-(int64_t dec) const
+    TableIteratorBase operator-(int64_t dec) const
     {
       return operator+(-dec);
     }
 
-    RowViewBase const& operator*() const
+    TableIteratorBase const& operator*() const
     {
       return *this;
     }
   };
-  template <typename P, typename... Ts>
-  using RowView = RowViewBase<DefaultIndexPolicy, P, Ts...>;
 
-  template <typename P, typename... Ts>
-  using RowViewFiltered = RowViewBase<FilteredIndexPolicy, P, Ts...>;
+  template <typename IP, typename Parent, typename... T>
+  using iterator_template = TableIteratorBase<IP, Parent, T...>;
+
+  template <typename IP, typename Parent>
+  static consteval auto full_iter()
+  {
+    if constexpr (sizeof...(Ts) == 0) {
+      return iterator_template<IP, Parent>{};
+    } else {
+      if constexpr ((o2::soa::is_column<Ts> && ...)) {
+        return iterator_template<IP, Parent>{};
+      } else {
+        return iterator_template<IP, Parent, Ts...>{};
+      }
+    }
+  }
+
+  template <typename IP, typename Parent>
+  using iterator_template_o = decltype(full_iter<IP, Parent>());
+
+  using iterator = iterator_template_o<DefaultIndexPolicy, table_t>;
+  using filtered_iterator = iterator_template_o<FilteredIndexPolicy, table_t>;
+
+  using unfiltered_iterator = iterator;
+  using const_iterator = iterator;
+  using unfiltered_const_iterator = unfiltered_iterator;
 
-  using iterator = RowView<table_t, table_t>;
-  using const_iterator = RowView<table_t, table_t>;
-  using unfiltered_iterator = RowView<table_t, table_t>;
-  using unfiltered_const_iterator = RowView<table_t, table_t>;
-  using filtered_iterator = RowViewFiltered<table_t, table_t>;
-  using filtered_const_iterator = RowViewFiltered<table_t, table_t>;
+  static constexpr auto hashes()
+  {
+    return []<typename... C>(framework::pack<C...>) { return std::set{{o2::framework::TypeIdHelpers::uniqueId<C>()...}}; }(columns_t{});
+  }
 
   Table(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
     : mTable(table),
@@ -1680,13 +1913,13 @@ class Table
       mOffset(offset)
   {
     if (mTable->num_rows() == 0) {
-      for (size_t ci = 0; ci < sizeof...(C); ++ci) {
+      for (size_t ci = 0; ci < framework::pack_size(columns_t{}); ++ci) {
         mColumnChunks[ci] = nullptr;
       }
       mBegin = mEnd;
     } else {
-      arrow::ChunkedArray* lookups[] = {lookupColumn<C>()...};
-      for (size_t ci = 0; ci < sizeof...(C); ++ci) {
+      auto lookups = [this]<typename... C>(framework::pack<C...>) -> std::array<arrow::ChunkedArray*, framework::pack_size(columns_t{})> { return {lookupColumn<C>()...}; }(columns_t{});
+      for (size_t ci = 0; ci < framework::pack_size(columns_t{}); ++ci) {
         mColumnChunks[ci] = lookups[ci];
       }
       mBegin = unfiltered_iterator{mColumnChunks, {table->num_rows(), offset}};
@@ -1694,24 +1927,35 @@ class Table
     }
   }
 
-  /// FIXME: this is to be able to construct a Filtered without explicit Join
-  ///        so that Filtered<Table1,Table2, ...> always means a Join which
-  ///        may or may not be a problem later
   Table(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
+    requires(ref.origin_hash != "CONC"_h)
     : Table(ArrowHelpers::joinTables(std::move(tables)), offset)
   {
   }
 
+  Table(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
+    requires(ref.origin_hash == "CONC"_h)
+    : Table(ArrowHelpers::concatTables(std::move(tables)), offset)
+  {
+  }
+
   template <typename Key>
   inline arrow::ChunkedArray* getIndexToKey()
   {
-    if constexpr (framework::has_type_conditional<is_binding_compatible, Key>(external_index_columns_t{})) {
-      using IC = framework::pack_element_t<framework::has_type_at_conditional_v<is_binding_compatible, Key>(external_index_columns_t{}), external_index_columns_t>;
-      return mColumnChunks[framework::has_type_at_v<IC>(persistent_columns_t{})];
-    } else if constexpr (std::is_same_v<table_t, Key>) {
-      return nullptr;
+    constexpr auto map = []<typename... Cs>(framework::pack<Cs...>) {
+      return std::array<bool, sizeof...(Cs)>{[]() {
+        if constexpr (requires { Cs::index_targets.size(); }) {
+          return Key::template isIndexTargetOf<Cs::index_targets.size(), Cs::index_targets>();
+        } else {
+          return false;
+        }
+      }()...};
+    }(persistent_columns_t{});
+    constexpr auto pos = std::find(map.begin(), map.end(), true);
+    if constexpr (pos != map.end()) {
+      return mColumnChunks[std::distance(map.begin(), pos)];
     } else {
-      static_assert(framework::always_static_assert_v<Key>, "This table does not have an index to this type");
+      static_assert(framework::always_static_assert_v<Key>, "This table does not have an index to given Key");
     }
   }
 
@@ -1862,10 +2106,6 @@ class Table
     return self_t{mTable->Slice(0, 0), 0};
   }
 
- protected:
-  /// Offset of the table within a larger table.
-  uint64_t mOffset;
-
  private:
   template <typename T>
   arrow::ChunkedArray* lookupColumn()
@@ -1877,68 +2117,16 @@ class Table
       return nullptr;
     }
   }
-  std::shared_ptr<arrow::Table> mTable;
+  std::shared_ptr<arrow::Table> mTable = nullptr;
+  uint64_t mOffset = 0;
   // Cached pointers to the ChunkedArray associated to a column
-  arrow::ChunkedArray* mColumnChunks[sizeof...(C)];
-  /// Cached begin iterator for this table.
-  unfiltered_iterator mBegin;
-  /// Cached end iterator for this table.
+  arrow::ChunkedArray* mColumnChunks[framework::pack_size(columns_t{})];
   RowViewSentinel mEnd;
+  iterator mBegin;
 };
 
-template <o2::framework::OriginEnc, typename T>
-struct PackToTable {
-  static_assert(framework::always_static_assert_v<T>, "Not a pack");
-};
-
-template <o2::framework::OriginEnc ORIGIN, typename... C>
-struct PackToTable<ORIGIN, framework::pack<C...>> {
-  using table = o2::soa::Table<ORIGIN, C...>;
-};
-
-template <o2::framework::OriginEnc ORIGIN, typename... T>
-struct TableWrap {
-  using all_columns = framework::concatenated_pack_unique_t<typename T::columns...>;
-  using table_t = typename PackToTable<ORIGIN, all_columns>::table;
-};
-
-template <o2::framework::OriginEnc ORIGIN, typename... T>
-struct TableIntersect {
-  using all_columns = framework::full_intersected_pack_t<typename T::columns...>;
-  using table_t = typename PackToTable<ORIGIN, all_columns>::table;
-};
-
-/// Template trait which allows to map a given
-/// Table type to its O2 DataModel origin and description
-template <typename INHERIT>
-class TableMetadata
-{
- public:
-  static constexpr char const* tableLabel() { return INHERIT::mLabel; }
-  // static constexpr char const (&origin())[5] { return INHERIT::table_t::mOrigin; }
-  static consteval auto origin() { return INHERIT::table_t::mOrigin; }
-  static constexpr char const (&description())[16] { return INHERIT::mDescription; }
-  static constexpr o2::header::DataHeader::SubSpecificationType version() { return INHERIT::mVersion; }
-  static std::string sourceSpec() { return fmt::format("{}/{:s}/{}/{}", INHERIT::mLabel, INHERIT::table_t::mOrigin, INHERIT::mDescription, INHERIT::mVersion); };
-};
-
-/// Helper templates to define universal join and concat
-template <o2::framework::OriginEnc ORIGIN, typename... T>
-constexpr auto join(T const&... t)
-{
-  return typename o2::soa::TableWrap<ORIGIN, T...>::table_t(ArrowHelpers::joinTables({t.asArrowTable()...}));
-}
-
-template <o2::framework::OriginEnc ORIGIN, typename... T>
-constexpr auto concat(T const&... t)
-{
-  return typename o2::soa::TableIntersect<ORIGIN, T...>::table_t(ArrowHelpers::concatTables({t.asArrowTable()...}));
-}
-
-template <typename T1, typename T2>
-using ConcatBase = decltype(concat<o2::framework::OriginEnc{"CONC"}>(std::declval<T1>(), std::declval<T2>()));
-
-void notBoundTable(const char* tableName);
+template <uint32_t D, soa::is_column... C>
+using InPlaceTable = Table<o2::aod::Hash<"TEST"_h>, o2::aod::Hash<D>, o2::aod::Hash<"TEST"_h>, C...>;
 
 namespace row_helpers
 {
@@ -1993,26 +2181,29 @@ std::tuple<typename Cs::type...> getRowData(arrow::Table* table, T rowIterator,
 
 namespace o2::aod
 {
-DECLARE_SOA_ITERATOR_METADATA();
-}
-
-#define DECLARE_SOA_VERSIONING()                                                                    \
-  template <typename T>                                                                             \
-  consteval int getVersion()                                                                        \
-  {                                                                                                 \
-    if constexpr (o2::soa::has_metadata<o2::aod::MetadataTrait<T>>) {                               \
-      return MetadataTrait<T>::metadata::version();                                                 \
-    } else if constexpr (o2::soa::is_type_with_originals_v<T>) {                                    \
-      return MetadataTrait<o2::framework::pack_head_t<typename T::originals>>::metadata::version(); \
-    } else {                                                                                        \
-      static_assert(o2::framework::always_static_assert_v<T>, "Not a versioned type");              \
-    }                                                                                               \
-  }
-
-#define DECLARE_EQUIVALENT_FOR_INDEX(_Base_, _Equiv_) \
-  template <>                                         \
-  struct EquivalentIndex<_Base_, _Equiv_> {           \
-    constexpr static bool value = true;               \
+O2ORIGIN("AOD");
+O2ORIGIN("AOD1");
+O2ORIGIN("AOD2");
+O2ORIGIN("DYN");
+O2ORIGIN("IDX");
+O2ORIGIN("JOIN");
+O2HASH("JOIN/0");
+O2ORIGIN("CONC");
+O2HASH("CONC/0");
+O2ORIGIN("TEST");
+O2HASH("TEST/0");
+} // namespace o2::aod
+
+#define DECLARE_EQUIVALENT_FOR_INDEX(_Base_, _Equiv_)                                                     \
+  template <>                                                                                             \
+  struct EquivalentIndexNG<o2::aod::Hash<_Base_::ref.desc_hash>, o2::aod::Hash<_Equiv_::ref.desc_hash>> { \
+    constexpr static bool value = true;                                                                   \
+  }
+
+#define DECLARE_EQUIVALENT_FOR_INDEX_NG(_Base_, _Equiv_)                              \
+  template <>                                                                         \
+  struct EquivalentIndexNG<o2::aod::Hash<_Base_ ""_h>, o2::aod::Hash<_Equiv_ ""_h>> { \
+    constexpr static bool value = true;                                               \
   }
 
 #define DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)                                                                                                                \
@@ -2141,6 +2332,13 @@ DECLARE_SOA_ITERATOR_METADATA();
 /// Array  index: return an array of iterators, defined by values in its elements
 
 /// SLICE
+
+template <o2::soa::is_table T>
+consteval auto getIndexTargets()
+{
+  return T::originals;
+}
+
 #define DECLARE_SOA_SLICE_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_) \
   struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> {                                 \
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
@@ -2150,6 +2348,7 @@ DECLARE_SOA_ITERATOR_METADATA();
     using type = _Type_[2];                                                                              \
     using column_t = _Name_##IdSlice;                                                                    \
     using binding_t = _Table_;                                                                           \
+    static constexpr auto index_targets = getIndexTargets<_Table_>();                                    \
     _Name_##IdSlice(arrow::ChunkedArray const* column)                                                   \
       : o2::soa::Column<_Type_[2], _Name_##IdSlice>(o2::soa::ColumnIterator<type>(column))               \
     {                                                                                                    \
@@ -2235,6 +2434,7 @@ DECLARE_SOA_ITERATOR_METADATA();
     using type = std::vector<_Type_>;                                                                    \
     using column_t = _Name_##Ids;                                                                        \
     using binding_t = _Table_;                                                                           \
+    static constexpr auto index_targets = getIndexTargets<_Table_>();                                    \
     _Name_##Ids(arrow::ChunkedArray const* column)                                                       \
       : o2::soa::Column<std::vector<_Type_>, _Name_##Ids>(o2::soa::ColumnIterator<type>(column))         \
     {                                                                                                    \
@@ -2389,6 +2589,7 @@ DECLARE_SOA_ITERATOR_METADATA();
     using type = _Type_;                                                                                                                                                     \
     using column_t = _Name_##Id;                                                                                                                                             \
     using binding_t = _Table_;                                                                                                                                               \
+    static constexpr auto index_targets = getIndexTargets<_Table_>();                                                                                                        \
     _Name_##Id(arrow::ChunkedArray const* column)                                                                                                                            \
       : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                                                                           \
     {                                                                                                                                                                        \
@@ -2461,7 +2662,7 @@ DECLARE_SOA_ITERATOR_METADATA();
 #define DECLARE_SOA_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
 
 /// SELF
-#define DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)                                                                                      \
+#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)                                                                   \
   struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                                                                        \
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                                                                      \
     static constexpr const char* mLabel = "fIndex" _Label_;                                                                                                        \
@@ -2469,6 +2670,7 @@ DECLARE_SOA_ITERATOR_METADATA();
     using type = _Type_;                                                                                                                                           \
     using column_t = _Name_##Id;                                                                                                                                   \
     using self_index_t = std::true_type;                                                                                                                           \
+    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>;                                                           \
     _Name_##Id(arrow::ChunkedArray const* column)                                                                                                                  \
       : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                                                                 \
     {                                                                                                                                                              \
@@ -2516,141 +2718,146 @@ DECLARE_SOA_ITERATOR_METADATA();
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_##Id>(), \
                                                                                            o2::framework::expressions::selectArrowType<_Type_>() }
 
+#define DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
 #define DECLARE_SOA_SELF_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, #_Name_)
 /// SELF SLICE
-#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)        \
-  struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> {                   \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");              \
-    static constexpr const char* mLabel = "fIndexSlice" _Label_;                           \
-    using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>;                              \
-    using type = _Type_[2];                                                                \
-    using column_t = _Name_##IdSlice;                                                      \
-    using self_index_t = std::true_type;                                                   \
-    _Name_##IdSlice(arrow::ChunkedArray const* column)                                     \
-      : o2::soa::Column<_Type_[2], _Name_##IdSlice>(o2::soa::ColumnIterator<type>(column)) \
-    {                                                                                      \
-    }                                                                                      \
-                                                                                           \
-    _Name_##IdSlice() = default;                                                           \
-    _Name_##IdSlice(_Name_##IdSlice const& other) = default;                               \
-    _Name_##IdSlice& operator=(_Name_##IdSlice const& other) = default;                    \
-    std::array<_Type_, 2> inline getIds() const                                            \
-    {                                                                                      \
-      return _Getter_##Ids();                                                              \
-    }                                                                                      \
-                                                                                           \
-    bool has_##_Getter_() const                                                            \
-    {                                                                                      \
-      auto a = *mColumnIterator;                                                           \
-      return a[0] >= 0 && a[1] >= 0;                                                       \
-    }                                                                                      \
-                                                                                           \
-    std::array<_Type_, 2> _Getter_##Ids() const                                            \
-    {                                                                                      \
-      auto a = *mColumnIterator;                                                           \
-      return std::array{a[0], a[1]};                                                       \
-    }                                                                                      \
-                                                                                           \
-    template <typename T>                                                                  \
-    auto _Getter_##_as() const                                                             \
-    {                                                                                      \
-      auto t = mBinding.get<T>();                                                          \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                             \
-        o2::soa::dereferenceWithWrongType();                                               \
-      }                                                                                    \
-      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                        \
-        return t->emptySlice();                                                            \
-      }                                                                                    \
-      auto a = *mColumnIterator;                                                           \
-      auto r = t->rawSlice(a[0], a[1]);                                                    \
-      t->copyIndexBindings(r);                                                             \
-      r.bindInternalIndicesTo(t);                                                          \
-      return r;                                                                            \
-    }                                                                                      \
-                                                                                           \
-    bool setCurrentRaw(o2::soa::Binding current)                                           \
-    {                                                                                      \
-      this->mBinding = current;                                                            \
-      return true;                                                                         \
-    }                                                                                      \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                            \
-    o2::soa::Binding mBinding;                                                             \
+#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)   \
+  struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> {                                 \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
+    static constexpr const char* mLabel = "fIndexSlice" _Label_;                                         \
+    using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>;                                            \
+    using type = _Type_[2];                                                                              \
+    using column_t = _Name_##IdSlice;                                                                    \
+    using self_index_t = std::true_type;                                                                 \
+    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>; \
+    _Name_##IdSlice(arrow::ChunkedArray const* column)                                                   \
+      : o2::soa::Column<_Type_[2], _Name_##IdSlice>(o2::soa::ColumnIterator<type>(column))               \
+    {                                                                                                    \
+    }                                                                                                    \
+                                                                                                         \
+    _Name_##IdSlice() = default;                                                                         \
+    _Name_##IdSlice(_Name_##IdSlice const& other) = default;                                             \
+    _Name_##IdSlice& operator=(_Name_##IdSlice const& other) = default;                                  \
+    std::array<_Type_, 2> inline getIds() const                                                          \
+    {                                                                                                    \
+      return _Getter_##Ids();                                                                            \
+    }                                                                                                    \
+                                                                                                         \
+    bool has_##_Getter_() const                                                                          \
+    {                                                                                                    \
+      auto a = *mColumnIterator;                                                                         \
+      return a[0] >= 0 && a[1] >= 0;                                                                     \
+    }                                                                                                    \
+                                                                                                         \
+    std::array<_Type_, 2> _Getter_##Ids() const                                                          \
+    {                                                                                                    \
+      auto a = *mColumnIterator;                                                                         \
+      return std::array{a[0], a[1]};                                                                     \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto _Getter_##_as() const                                                                           \
+    {                                                                                                    \
+      auto t = mBinding.get<T>();                                                                        \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
+        o2::soa::dereferenceWithWrongType();                                                             \
+      }                                                                                                  \
+      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                      \
+        return t->emptySlice();                                                                          \
+      }                                                                                                  \
+      auto a = *mColumnIterator;                                                                         \
+      auto r = t->rawSlice(a[0], a[1]);                                                                  \
+      t->copyIndexBindings(r);                                                                           \
+      r.bindInternalIndicesTo(t);                                                                        \
+      return r;                                                                                          \
+    }                                                                                                    \
+                                                                                                         \
+    bool setCurrentRaw(o2::soa::Binding current)                                                         \
+    {                                                                                                    \
+      this->mBinding = current;                                                                          \
+      return true;                                                                                       \
+    }                                                                                                    \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                          \
+    o2::soa::Binding mBinding;                                                                           \
   };
 
+#define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
 #define DECLARE_SOA_SELF_SLICE_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_SLICE_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, "_" #_Name_)
 /// SELF ARRAY
-#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)              \
-  struct _Name_##Ids : o2::soa::Column<std::vector<_Type_>, _Name_##Ids> {                       \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                    \
-    static constexpr const char* mLabel = "fIndexArray" _Label_;                                 \
-    using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>;                              \
-    using type = std::vector<_Type_>;                                                            \
-    using column_t = _Name_##Ids;                                                                \
-    using self_index_t = std::true_type;                                                         \
-    _Name_##Ids(arrow::ChunkedArray const* column)                                               \
-      : o2::soa::Column<std::vector<_Type_>, _Name_##Ids>(o2::soa::ColumnIterator<type>(column)) \
-    {                                                                                            \
-    }                                                                                            \
-                                                                                                 \
-    _Name_##Ids() = default;                                                                     \
-    _Name_##Ids(_Name_##Ids const& other) = default;                                             \
-    _Name_##Ids& operator=(_Name_##Ids const& other) = default;                                  \
-    gsl::span<const _Type_> inline getIds() const                                                \
-    {                                                                                            \
-      return _Getter_##Ids();                                                                    \
-    }                                                                                            \
-                                                                                                 \
-    gsl::span<const _Type_> _Getter_##Ids() const                                                \
-    {                                                                                            \
-      return *mColumnIterator;                                                                   \
-    }                                                                                            \
-                                                                                                 \
-    bool has_##_Getter_() const                                                                  \
-    {                                                                                            \
-      return !(*mColumnIterator).empty();                                                        \
-    }                                                                                            \
-                                                                                                 \
-    template <typename T>                                                                        \
-    auto _Getter_##_as() const                                                                   \
-    {                                                                                            \
-      auto t = mBinding.get<T>();                                                                \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                   \
-        o2::soa::dereferenceWithWrongType();                                                     \
-      }                                                                                          \
-      return getIterators<T>();                                                                  \
-    }                                                                                            \
-                                                                                                 \
-    template <typename T>                                                                        \
-    auto getIterators() const                                                                    \
-    {                                                                                            \
-      auto result = std::vector<typename T::unfiltered_iterator>();                              \
-      for (auto& i : *mColumnIterator) {                                                         \
-        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                   \
-      }                                                                                          \
-      return result;                                                                             \
-    }                                                                                            \
-                                                                                                 \
-    template <typename T>                                                                        \
-    auto _Getter_##_first_as() const                                                             \
-    {                                                                                            \
-      return mBinding.get<T>()->rawIteratorAt((*mColumnIterator)[0]);                            \
-    }                                                                                            \
-                                                                                                 \
-    template <typename T>                                                                        \
-    auto _Getter_##_last_as() const                                                              \
-    {                                                                                            \
-      return mBinding.get<T>()->rawIteratorAt((*mColumnIterator).back());                        \
-    }                                                                                            \
-                                                                                                 \
-    bool setCurrentRaw(o2::soa::Binding current)                                                 \
-    {                                                                                            \
-      this->mBinding = current;                                                                  \
-      return true;                                                                               \
-    }                                                                                            \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                  \
-    o2::soa::Binding mBinding;                                                                   \
+#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)   \
+  struct _Name_##Ids : o2::soa::Column<std::vector<_Type_>, _Name_##Ids> {                               \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
+    static constexpr const char* mLabel = "fIndexArray" _Label_;                                         \
+    using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>;                                      \
+    using type = std::vector<_Type_>;                                                                    \
+    using column_t = _Name_##Ids;                                                                        \
+    using self_index_t = std::true_type;                                                                 \
+    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>; \
+    _Name_##Ids(arrow::ChunkedArray const* column)                                                       \
+      : o2::soa::Column<std::vector<_Type_>, _Name_##Ids>(o2::soa::ColumnIterator<type>(column))         \
+    {                                                                                                    \
+    }                                                                                                    \
+                                                                                                         \
+    _Name_##Ids() = default;                                                                             \
+    _Name_##Ids(_Name_##Ids const& other) = default;                                                     \
+    _Name_##Ids& operator=(_Name_##Ids const& other) = default;                                          \
+    gsl::span<const _Type_> inline getIds() const                                                        \
+    {                                                                                                    \
+      return _Getter_##Ids();                                                                            \
+    }                                                                                                    \
+                                                                                                         \
+    gsl::span<const _Type_> _Getter_##Ids() const                                                        \
+    {                                                                                                    \
+      return *mColumnIterator;                                                                           \
+    }                                                                                                    \
+                                                                                                         \
+    bool has_##_Getter_() const                                                                          \
+    {                                                                                                    \
+      return !(*mColumnIterator).empty();                                                                \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto _Getter_##_as() const                                                                           \
+    {                                                                                                    \
+      auto t = mBinding.get<T>();                                                                        \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
+        o2::soa::dereferenceWithWrongType();                                                             \
+      }                                                                                                  \
+      return getIterators<T>();                                                                          \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto getIterators() const                                                                            \
+    {                                                                                                    \
+      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
+      for (auto& i : *mColumnIterator) {                                                                 \
+        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
+      }                                                                                                  \
+      return result;                                                                                     \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto _Getter_##_first_as() const                                                                     \
+    {                                                                                                    \
+      return mBinding.get<T>()->rawIteratorAt((*mColumnIterator)[0]);                                    \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto _Getter_##_last_as() const                                                                      \
+    {                                                                                                    \
+      return mBinding.get<T>()->rawIteratorAt((*mColumnIterator).back());                                \
+    }                                                                                                    \
+                                                                                                         \
+    bool setCurrentRaw(o2::soa::Binding current)                                                         \
+    {                                                                                                    \
+      this->mBinding = current;                                                                          \
+      return true;                                                                                       \
+    }                                                                                                    \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                          \
+    o2::soa::Binding mBinding;                                                                           \
   };
 
+#define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
 #define DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_ARRAY_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, "_" #_Name_)
 
 /// A dynamic column is a column whose values are derived
@@ -2733,135 +2940,140 @@ DECLARE_SOA_ITERATOR_METADATA();
     std::tuple<o2::soa::ColumnIterator<typename Bindings::type> const*...> boundIterators;                                 \
   }
 
-#define DECLARE_SOA_TABLE_FULL_VERSIONED(_Name_, _Label_, _Origin_, _Description_, _Version_, ...) \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                  \
-  using _Name_##From = o2::soa::Table<ORIGIN, __VA_ARGS__>;                                        \
-  using _Name_ = _Name_##From<o2::framework::OriginEnc{_Origin_}>;                                 \
-                                                                                                   \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                  \
-  struct _Name_##Metadata : o2::soa::TableMetadata<_Name_##Metadata<ORIGIN>> {                     \
-    using table_t = _Name_##From<ORIGIN>;                                                          \
-    static constexpr o2::header::DataHeader::SubSpecificationType mVersion = _Version_;            \
-    static constexpr char const* mLabel = _Label_;                                                 \
-    static constexpr char const mDescription[16] = _Description_;                                  \
-  };                                                                                               \
-                                                                                                   \
-  template <o2::framework::OriginEnc ORIGIN>                                                       \
-  struct MetadataTrait<_Name_##From<ORIGIN>> {                                                     \
-    using metadata = _Name_##Metadata<ORIGIN>;                                                     \
-  };                                                                                               \
-                                                                                                   \
-  template <>                                                                                      \
-  struct MetadataTrait<_Name_> {                                                                   \
-    using metadata = _Name_##Metadata<o2::framework::OriginEnc{_Origin_}>;                         \
+#define DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, ...) \
+  using _Name_##Metadata = TableMetadata<Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__>;
+
+#define DECLARE_SOA_TABLE_METADATA_TRAIT(_Name_, _Desc_, _Version_) \
+  template <>                                                       \
+  struct MetadataTrait<Hash<_Desc_ "/" #_Version_ ""_h>> {          \
+    using metadata = _Name_##Metadata;                              \
   };
 
-#define DECLARE_SOA_TABLE_FULL(_Name_, _Label_, _Origin_, _Description_, ...) \
-  DECLARE_SOA_TABLE_FULL_VERSIONED(_Name_, _Label_, _Origin_, _Description_, 0, __VA_ARGS__);
-#define DECLARE_SOA_TABLE(_Name_, _Origin_, _Description_, ...) \
-  DECLARE_SOA_TABLE_FULL(_Name_, #_Name_, _Origin_, _Description_, __VA_ARGS__);
-#define DECLARE_SOA_TABLE_VERSIONED(_Name_, _Origin_, _Description_, _Version_, ...) \
-  DECLARE_SOA_TABLE_FULL_VERSIONED(_Name_, #_Name_, _Origin_, _Description_, _Version_, __VA_ARGS__);
-
-#define DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Description_, _Version_, ...)                      \
-  DECLARE_SOA_TABLE_FULL_VERSIONED(_BaseName_, #_BaseName_, "AOD", _Description_, _Version_, __VA_ARGS__); \
-  DECLARE_SOA_TABLE_FULL_VERSIONED(Stored##_BaseName_, "Stored" #_BaseName_, "AOD1", _Description_, _Version_, __VA_ARGS__, soa::Marker<1>);
-
-#define DECLARE_SOA_TABLE_STAGED(_BaseName_, _Description_, ...) \
-  DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Description_, 0, __VA_ARGS__);
-
-#define DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Table_, _Origin_, _Description_, ...)                                                      \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                                                           \
-  struct _Name_##ExtensionFrom : o2::soa::Table<ORIGIN, __VA_ARGS__> {                                                                      \
-    using base_t = o2::soa::Table<ORIGIN, __VA_ARGS__>;                                                                                     \
-    _Name_##ExtensionFrom(std::shared_ptr<arrow::Table> table, uint64_t offset = 0) : o2::soa::Table<ORIGIN, __VA_ARGS__>(table, offset){}; \
-    _Name_##ExtensionFrom(_Name_##ExtensionFrom const&) = default;                                                                          \
-    _Name_##ExtensionFrom(_Name_##ExtensionFrom&&) = default;                                                                               \
-    using expression_pack_t = framework::pack<__VA_ARGS__>;                                                                                 \
-    using iterator = typename base_t::template RowView<_Name_##ExtensionFrom<ORIGIN>, _Name_##ExtensionFrom<ORIGIN>>;                       \
-    using const_iterator = iterator;                                                                                                        \
-  };                                                                                                                                        \
-  using _Name_##Extension = _Name_##ExtensionFrom<o2::framework::OriginEnc{_Origin_}>;                                                      \
-  template <o2::framework::OriginEnc ORIGIN>                                                                                                \
-  using _Name_##From = o2::soa::Join<_Name_##ExtensionFrom<ORIGIN>, _Table_>;                                                               \
-  using _Name_ = _Name_##From<o2::framework::OriginEnc{_Origin_}>;                                                                          \
-                                                                                                                                            \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                                                           \
-  struct _Name_##ExtensionMetadata : o2::soa::TableMetadata<_Name_##ExtensionMetadata<ORIGIN>> {                                            \
-    using table_t = _Name_##ExtensionFrom<ORIGIN>;                                                                                          \
-    using base_table_t = _Table_;                                                                                                           \
-    using expression_pack_t = typename _Name_##ExtensionFrom<ORIGIN>::expression_pack_t;                                                    \
-    using originals = soa::originals_pack_t<_Table_>;                                                                                       \
-    using sources = originals;                                                                                                              \
-    static constexpr o2::header::DataHeader::SubSpecificationType mVersion = getVersion<_Table_>();                                         \
-    static constexpr char const* mLabel = #_Name_ "Extension";                                                                              \
-    static constexpr char const mDescription[16] = _Description_;                                                                           \
-  };                                                                                                                                        \
-                                                                                                                                            \
-  template <>                                                                                                                               \
-  struct MetadataTrait<_Name_##Extension> {                                                                                                 \
-    using metadata = _Name_##ExtensionMetadata<o2::framework::OriginEnc{"DYN"}>;                                                            \
+#define DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, _Version_)         \
+  O2HASH(_Desc_ "/" #_Version_);                                                                \
+  template <typename O>                                                                         \
+  using _Name_##From = o2::soa::Table<Hash<_Label_ ""_h>, Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
+  using _Name_ = _Name_##From<Hash<_Origin_ ""_h>>;                                             \
+  template <>                                                                                   \
+  struct MetadataTrait<Hash<_Desc_ "/" #_Version_ ""_h>> {                                      \
+    using metadata = _Name_##Metadata;                                                          \
   };
 
-#define DECLARE_SOA_EXTENDED_TABLE(_Name_, _Table_, _Description_, ...) \
-  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Table_, "DYN", _Description_, __VA_ARGS__)
+#define DECLARE_SOA_STAGE(_Name_, _Origin_, _Desc_, _Version_)                                  \
+  template <typename O>                                                                         \
+  using _Name_##From = o2::soa::Table<Hash<#_Name_ ""_h>, Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
+  using _Name_ = _Name_##From<Hash<_Origin_ ""_h>>;
+
+#define DECLARE_SOA_TABLE_FULL_VERSIONED(_Name_, _Label_, _Origin_, _Desc_, _Version_, ...) \
+  DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, __VA_ARGS__);                       \
+  DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, _Version_);
+
+#define DECLARE_SOA_TABLE_FULL(_Name_, _Label_, _Origin_, _Desc_, ...) \
+  O2HASH(_Label_);                                                     \
+  DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, 0, __VA_ARGS__);          \
+  DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, _Label_, _Origin_, _Desc_, 0)
+
+#define DECLARE_SOA_TABLE(_Name_, _Origin_, _Desc_, ...) \
+  DECLARE_SOA_TABLE_FULL(_Name_, #_Name_, _Origin_, _Desc_, __VA_ARGS__)
+
+#define DECLARE_SOA_TABLE_VERSIONED(_Name_, _Origin_, _Desc_, _Version_, ...) \
+  O2HASH(#_Name_);                                                            \
+  DECLARE_SOA_TABLE_METADATA(_Name_, _Desc_, _Version_, __VA_ARGS__);         \
+  DECLARE_SOA_TABLE_FULL_VERSIONED_(_Name_, #_Name_, _Origin_, _Desc_, _Version_)
+
+#define DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Desc_, _Version_, ...) \
+  O2HASH(_Desc_ "/" #_Version_);                                               \
+  O2HASH(#_BaseName_);                                                         \
+  O2HASH("Stored" #_BaseName_);                                                \
+  DECLARE_SOA_TABLE_METADATA(_BaseName_, _Desc_, _Version_, __VA_ARGS__);      \
+  using Stored##_BaseName_##Metadata = _BaseName_##Metadata;                   \
+  DECLARE_SOA_TABLE_METADATA_TRAIT(_BaseName_, _Desc_, _Version_);             \
+  DECLARE_SOA_STAGE(_BaseName_, "AOD", _Desc_, _Version_);                     \
+  DECLARE_SOA_STAGE(Stored##_BaseName_, "AOD1", _Desc_, _Version_);
+
+#define DECLARE_SOA_TABLE_STAGED(_BaseName_, _Desc_, ...) \
+  DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Desc_, 0, __VA_ARGS__);
+
+#define DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...)                     \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                \
+  template <typename O>                                                                                                         \
+  using _Name_##ExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;          \
+  using _Name_##Extension = _Name_##ExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                          \
+  struct _Name_##ExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                \
+    using base_table_t = _OriginalTable_;                                                                                       \
+    using extension_table_t = _Name_##ExtensionFrom<O>;                                                                         \
+    using expression_pack_t = framework::pack<__VA_ARGS__>;                                                                     \
+    static constexpr auto sources = _OriginalTable_::originals;                                                                 \
+  };                                                                                                                            \
+  using _Name_##ExtensionMetadata = _Name_##ExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                \
+  template <>                                                                                                                   \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                             \
+    using metadata = _Name_##ExtensionMetadata;                                                                                 \
+  };                                                                                                                            \
+  template <typename O>                                                                                                         \
+  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##ExtensionFrom<O>>; \
+  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+
+#define DECLARE_SOA_EXTENDED_TABLE(_Name_, _Table_, _Description_, _Version_, ...) \
+  O2HASH(#_Name_ "Extension");                                                     \
+  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "DYN", _Description_, _Version_, __VA_ARGS__)
 
 #define DECLARE_SOA_EXTENDED_TABLE_USER(_Name_, _Table_, _Description_, ...) \
-  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Table_, "AOD", _Description_, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Description_, _Exclusive_, ...)                                                 \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                                                              \
-  struct _Name_##From : o2::soa::IndexTable<ORIGIN, _Key_, __VA_ARGS__> {                                                                      \
-    using base_t = o2::soa::IndexTable<ORIGIN, _Key_, __VA_ARGS__>;                                                                            \
-    _Name_##From(std::shared_ptr<arrow::Table> table, uint64_t offset = 0) : o2::soa::IndexTable<ORIGIN, _Key_, __VA_ARGS__>(table, offset){}; \
-    _Name_##From(_Name_##From const&) = default;                                                                                               \
-    _Name_##From(_Name_##From&&) = default;                                                                                                    \
-    using iterator = typename base_t::template RowView<_Name_##From<ORIGIN>, _Name_##From<ORIGIN>>;                                            \
-    using const_iterator = iterator;                                                                                                           \
-  };                                                                                                                                           \
-  using _Name_ = _Name_##From<o2::framework::OriginEnc{_Origin_}>;                                                                             \
-                                                                                                                                               \
-  template <o2::framework::OriginEnc ORIGIN = o2::framework::OriginEnc{_Origin_}>                                                              \
-  struct _Name_##Metadata : o2::soa::TableMetadata<_Name_##Metadata<ORIGIN>> {                                                                 \
-    using table_t = _Name_##From<ORIGIN>;                                                                                                      \
-    using Key = _Key_;                                                                                                                         \
-    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                         \
-    using originals = decltype(soa::extractBindings(index_pack_t{}));                                                                          \
-    using sources = typename _Name_##From<ORIGIN>::sources_t;                                                                                  \
-    static constexpr o2::header::DataHeader::SubSpecificationType mVersion = 0;                                                                \
-    static constexpr char const* mLabel = #_Name_;                                                                                             \
-    static constexpr char const mDescription[16] = _Description_;                                                                              \
-    static constexpr bool exclusive = _Exclusive_;                                                                                             \
-  };                                                                                                                                           \
-                                                                                                                                               \
-  template <o2::framework::OriginEnc ORIGIN>                                                                                                   \
-  struct MetadataTrait<_Name_##From<ORIGIN>> {                                                                                                 \
-    using metadata = _Name_##Metadata<ORIGIN>;                                                                                                 \
+  O2HASH(#_Name_ "Extension");                                               \
+  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
+
+#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...)                                         \
+  O2HASH(#_Name_);                                                                                                                         \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                           \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                     \
+  struct _Name_##MetadataFrom : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> {             \
+    static constexpr bool exclusive = _Exclusive_;                                                                                         \
+    using Key = _Key_;                                                                                                                     \
+    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                     \
+    static constexpr const auto sources = []<typename... Cs>(framework::pack<Cs...>) {                                                     \
+      constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                             \
+      return o2::aod::filterForKey<a.size(), a, Key>();                                                                                    \
+    }(framework::pack<__VA_ARGS__>{});                                                                                                     \
+  };                                                                                                                                       \
+  using _Name_##Metadata = _Name_##MetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                             \
+                                                                                                                                           \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                     \
+  using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_, __VA_ARGS__>; \
+  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;                                                                               \
+                                                                                                                                           \
+  template <>                                                                                                                              \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                        \
+    using metadata = _Name_##Metadata;                                                                                                     \
   };
 
 #define DECLARE_SOA_INDEX_TABLE(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", _Description_, false, __VA_ARGS__)
+  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, false, __VA_ARGS__)
 
 #define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", _Description_, true, __VA_ARGS__)
+  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, true, __VA_ARGS__)
 
 #define DECLARE_SOA_INDEX_TABLE_USER(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", _Description_, false, __VA_ARGS__)
+  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, false, __VA_ARGS__)
 
 #define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE_USER(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", _Description_, true, __VA_ARGS__)
+  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, true, __VA_ARGS__)
 
 namespace o2::soa
 {
-template <typename T>
-class FilteredBase;
+// template <typename T>
+// class FilteredBase;
 
-template <typename... Ts>
-struct Join : TableWrap<o2::framework::OriginEnc{"JOIN"}, Ts...>::table_t {
-  using base = typename TableWrap<o2::framework::OriginEnc{"JOIN"}, Ts...>::table_t;
-  using originals = originals_pack_t<Ts...>;
+template <typename D, typename... Ts>
+struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...> {
+  using base = Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...>;
 
-  Join(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
+  JoinFull(std::shared_ptr<arrow::Table>&& table, uint64_t offset = 0)
+    : base{std::move(table), offset}
+  {
+    bindInternalIndicesTo(this);
+  }
+  JoinFull(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
     : base{ArrowHelpers::joinTables(std::move(tables)), offset}
   {
     bindInternalIndicesTo(this);
@@ -2869,14 +3081,16 @@ struct Join : TableWrap<o2::framework::OriginEnc{"JOIN"}, Ts...>::table_t {
   using base::bindExternalIndices;
   using base::bindInternalIndicesTo;
 
-  using self_t = Join<Ts...>;
+  using self_t = JoinFull<D, Ts...>;
   using table_t = base;
+  static constexpr const auto originals = base::originals;
+  using columns_t = typename table_t::columns_t;
   using persistent_columns_t = typename table_t::persistent_columns_t;
-  using iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowView<Join<Ts...>, Os...>{}; }(originals{}));
+  using iterator = table_t::template iterator_template<DefaultIndexPolicy, self_t, Ts...>;
   using const_iterator = iterator;
   using unfiltered_iterator = iterator;
   using unfiltered_const_iterator = const_iterator;
-  using filtered_iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowViewFiltered<Filtered<Join<Ts...>>, Os...>{}; }(originals{}));
+  using filtered_iterator = table_t::template iterator_template<FilteredIndexPolicy, self_t, Ts...>;
   using filtered_const_iterator = filtered_iterator;
 
   iterator begin()
@@ -2930,73 +3144,76 @@ struct Join : TableWrap<o2::framework::OriginEnc{"JOIN"}, Ts...>::table_t {
   template <typename T>
   static consteval bool contains()
   {
-    if constexpr (is_type_with_originals_v<T>) {
-      return contains(typename T::originals{});
-    } else {
-      return framework::has_type<T>(originals{});
-    }
-  }
-
-  template <typename... TTs>
-  static constexpr bool contains(framework::pack<TTs...>)
-  {
-    return (contains<TTs>() || ...);
+    return std::find_if(originals.begin(), originals.end(), [](TableRef const& ref) { return ref.desc_hash == T::ref.desc_hash; }) != originals.end();
   }
 };
 
-template <typename T1, typename T2>
-struct Concat : ConcatBase<T1, T2> {
-  Concat(std::shared_ptr<arrow::Table> t1, std::shared_ptr<arrow::Table> t2, uint64_t offset = 0)
-    : ConcatBase<T1, T2>{ArrowHelpers::concatTables({t1, t2}), offset}
+template <typename... Ts>
+using Join = JoinFull<o2::aod::Hash<"JOIN/0"_h>, Ts...>;
+
+template <typename... Ts>
+constexpr auto join(Ts const&... t)
+{
+  return Join<Ts...>(ArrowHelpers::joinTables({t.asArrowTable()...}));
+}
+
+template <typename T>
+concept is_join = framework::specialization_of_template<JoinFull, T>;
+
+template <typename T>
+constexpr bool is_soa_join_v = is_join<T>;
+
+template <typename... Ts>
+struct Concat : Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::aod::Hash<"CONC"_h>, Ts...> {
+  using base = Table<o2::aod::Hash<"CONC"_h>, o2::aod::Hash<"CONC/0"_h>, o2::aod::Hash<"CONC"_h>, Ts...>;
+  using self_t = Concat<Ts...>;
+  Concat(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
+    : base{ArrowHelpers::concatTables(std::move(tables)), offset}
   {
     bindInternalIndicesTo(this);
   }
-  Concat(std::vector<std::shared_ptr<arrow::Table>> tables, uint64_t offset = 0)
-    : ConcatBase<T1, T2>{ArrowHelpers::concatTables(std::move(tables)), offset}
+  Concat(Ts const&... t, uint64_t offset = 0)
+    : base{ArrowHelpers::concatTables({t.asArrowTable()...}), offset}
   {
     bindInternalIndicesTo(this);
   }
 
-  using base = ConcatBase<T1, T2>;
-  using originals = framework::concatenated_pack_t<originals_pack_t<T1>, originals_pack_t<T2>>;
+  using base::originals;
 
   using base::bindExternalIndices;
   using base::bindInternalIndicesTo;
 
-  // FIXME: can be remove when we do the same treatment we did for Join to Concatenate
-  using left_t = T1;
-  using right_t = T2;
-  using table_t = ConcatBase<T1, T2>;
+  using table_t = base;
+  using columns_t = typename table_t::columns_t;
   using persistent_columns_t = typename table_t::persistent_columns_t;
 
-  using iterator = typename table_t::template RowView<Concat<T1, T2>, T1, T2>;
-  using filtered_iterator = typename table_t::template RowViewFiltered<Concat<T1, T2>, T1, T2>;
+  using iterator = table_t::template iterator_template<DefaultIndexPolicy, self_t, Ts...>;
+  using const_iterator = iterator;
+  using unfiltered_iterator = iterator;
+  using unfiltered_const_iterator = const_iterator;
+  using filtered_iterator = table_t::template iterator_template<FilteredIndexPolicy, self_t, Ts...>;
+  using filtered_const_iterator = filtered_iterator;
 };
 
-template <typename T>
-using is_soa_join_t = framework::is_specialization<T, soa::Join>;
-
-template <typename T>
-using is_soa_concat_t = framework::is_specialization<T, soa::Concat>;
-
-template <typename T>
-inline constexpr bool is_soa_join_v = is_soa_join_t<T>::value;
-
-template <typename T>
-inline constexpr bool is_soa_concat_v = is_soa_concat_t<T>::value;
+template <typename... Ts>
+constexpr auto concat(Ts const&... t)
+{
+  return Concat<Ts...>{t...};
+}
 
 template <typename T>
 class FilteredBase : public T
 {
  public:
   using self_t = FilteredBase<T>;
-  using originals = originals_pack_t<T>;
   using table_t = typename T::table_t;
+  using T::originals;
+  using columns_t = typename T::columns_t;
   using persistent_columns_t = typename T::persistent_columns_t;
   using external_index_columns_t = typename T::external_index_columns_t;
 
-  using iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowViewFiltered<FilteredBase<T>, Os...>{}; }(originals{}));
-  using unfiltered_iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowView<FilteredBase<T>, Os...>{}; }(originals{}));
+  using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
+  using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
   using const_iterator = iterator;
 
   FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gandiva::Selection const& selection, uint64_t offset = 0)
@@ -3257,10 +3474,9 @@ class Filtered : public FilteredBase<T>
   using base_t = T;
   using self_t = Filtered<T>;
   using table_t = typename FilteredBase<T>::table_t;
-  using originals = originals_pack_t<T>;
 
-  using iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowViewFiltered<Filtered<T>, Os...>{}; }(originals{}));
-  using unfiltered_iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowView<Filtered<T>, Os...>{}; }(originals{}));
+  using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
+  using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
   using const_iterator = iterator;
 
   iterator begin()
@@ -3417,9 +3633,9 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
   using self_t = Filtered<Filtered<T>>;
   using base_t = T;
   using table_t = typename FilteredBase<typename T::table_t>::table_t;
-  using originals = originals_pack_t<T>;
-  using iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowViewFiltered<Filtered<Filtered<T>>, Os...>{}; }(originals{}));
-  using unfiltered_iterator = decltype([]<typename... Os>(framework::pack<Os...>) { return typename table_t::template RowView<Filtered<Filtered<T>>, Os...>{}; }(originals{}));
+
+  using iterator = FilteredBase<typename T::table_t>::iterator;
+  using unfiltered_iterator = FilteredBase<typename T::table_t>::unfiltered_iterator;
   using const_iterator = iterator;
 
   iterator begin()
@@ -3584,33 +3800,37 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
 /// First argument is the key table (BCs for the Collisions+ZDCs case), the rest
 /// are index columns defined for the required tables.
 /// First index will be used by process() as the grouping
-template <o2::framework::OriginEnc ORIGIN, typename Key, typename H, typename... Ts>
-struct IndexTable : Table<ORIGIN, soa::Index<>, H, Ts...> {
-  using base_t = Table<ORIGIN, soa::Index<>, H, Ts...>;
+template <typename L, typename D, typename O, typename Key, typename H, typename... Ts>
+struct IndexTable : Table<L, D, O> {
+  using self_t = IndexTable<L, D, O, Key, H, Ts...>;
+  using base_t = Table<L, D, O>;
   using table_t = base_t;
-  using safe_base_t = Table<ORIGIN, H, Ts...>;
+  using safe_base_t = Table<L, D, O>;
   using indexing_t = Key;
   using first_t = typename H::binding_t;
   using rest_t = framework::pack<typename Ts::binding_t...>;
-  using sources_t = originals_pack_t<Key, first_t, typename Ts::binding_t...>;
 
   IndexTable(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
     : base_t{table, offset}
   {
   }
 
+  IndexTable(std::vector<std::shared_ptr<arrow::Table>> tables, uint64_t offset = 0)
+    : base_t{tables[0], offset}
+  {
+  }
+
   IndexTable(IndexTable const&) = default;
   IndexTable(IndexTable&&) = default;
   IndexTable& operator=(IndexTable const&) = default;
   IndexTable& operator=(IndexTable&&) = default;
 
-  using iterator = typename base_t::template RowView<IndexTable<ORIGIN, Key, H, Ts...>, IndexTable<ORIGIN, Key, H, Ts...>>;
+  using iterator = typename base_t::template iterator_template_o<DefaultIndexPolicy, self_t>;
   using const_iterator = iterator;
+  using filtered_iterator = typename base_t::template iterator_template_o<FilteredIndexPolicy, self_t>;
+  using const_filtered_iterator = filtered_iterator;
 };
 
-template <typename T>
-inline constexpr bool is_soa_index_table_v = soa::is_base_of_template_origin_v<soa::IndexTable, T>;
-
 template <typename T, bool APPLY>
 struct SmallGroupsBase : public Filtered<T> {
   static constexpr bool applyFilters = APPLY;
@@ -3631,16 +3851,9 @@ template <typename T>
 using SmallGroupsUnfiltered = SmallGroupsBase<T, false>;
 
 template <typename T>
-struct is_smallgroups_t {
-  static constexpr bool value = false;
-};
-
-template <typename T, bool F>
-struct is_smallgroups_t<SmallGroupsBase<T, F>> {
-  static constexpr bool value = true;
+concept is_smallgroups = requires {
+  []<typename B, bool A>(SmallGroupsBase<B, A>*) {}(std::declval<T*>());
 };
-
-template <typename T>
-constexpr bool is_smallgroups_v = is_smallgroups_t<T>::value;
 } // namespace o2::soa
+
 #endif // O2_FRAMEWORK_ASOA_H_
diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index fb9480e97ddfb..6de6662769ef7 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -1294,7 +1294,7 @@ struct CombinationsGenerator {
 template <typename T2, typename... T2s>
 constexpr bool isSameType()
 {
-  return std::conjunction_v<std::is_same<T2, T2s>...>;
+  return (std::same_as<T2, T2s> && ...);
 }
 
 template <typename BP, typename T1, typename... T2s>
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index e277925ed5603..860e220193c19 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -17,7 +17,6 @@
 #include <bitset>
 #include <limits>
 #include <numeric>
-#include <utility> // std::move
 
 #include "Framework/DataTypes.h"
 #include "CommonConstants/MathConstants.h"
@@ -31,11 +30,6 @@ namespace o2
 {
 namespace aod
 {
-// This is required to register SOA_TABLEs inside
-// the o2::aod namespace.
-// DECLARE_SOA_METADATA();
-DECLARE_SOA_VERSIONING();
-
 namespace bc
 {
 DECLARE_SOA_COLUMN(RunNumber, runNumber, int);          //! Run number
@@ -66,15 +60,16 @@ DECLARE_SOA_COLUMN(Timestamp, timestamp, uint64_t); //! Timestamp of a BC in ms
 
 DECLARE_SOA_TABLE(Timestamps, "AOD", "TIMESTAMPS", //! Table which holds the timestamp of a BC
                   timestamp::Timestamp);
+
+using BCsWithTimestamps = soa::Join<aod::BCs, aod::Timestamps>;
 } // namespace aod
+
 namespace soa
 {
-extern template struct Join<aod::BCs, aod::Timestamps>;
+extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::BCs, aod::Timestamps>;
 }
 namespace aod
 {
-using BCsWithTimestamps = soa::Join<aod::BCs, aod::Timestamps>;
-
 namespace collision
 {
 DECLARE_SOA_INDEX_COLUMN(BC, bc);                              //! Most probably BC to where this collision has occured
@@ -478,7 +473,7 @@ DECLARE_SOA_TABLE_FULL(StoredTracks, "Tracks", "AOD", "TRACK", //! On disk versi
                        track::Sign<track::Signed1Pt>,
                        o2::soa::Marker<1>);
 
-DECLARE_SOA_EXTENDED_TABLE(Tracks, StoredTracks, "TRACK", //! Track parameters at collision vertex
+DECLARE_SOA_EXTENDED_TABLE(Tracks, StoredTracks, "EXTRACK", 0, //! Track parameters at collision vertex
                            aod::track::Pt,
                            aod::track::P,
                            aod::track::Eta,
@@ -498,7 +493,7 @@ DECLARE_SOA_TABLE_FULL(StoredTracksIU, "Tracks_IU", "AOD", "TRACK_IU", //! On di
                        track::Sign<track::Signed1Pt>,
                        o2::soa::Marker<2>);
 
-DECLARE_SOA_EXTENDED_TABLE(TracksIU, StoredTracksIU, "TRACK_IU", //! Track parameters at inner most update (e.g. ITS) as it comes from the tracking
+DECLARE_SOA_EXTENDED_TABLE(TracksIU, StoredTracksIU, "EXTRACK_IU", 0, //! Track parameters at inner most update (e.g. ITS) as it comes from the tracking
                            aod::track::Pt,
                            aod::track::P,
                            aod::track::Eta,
@@ -509,7 +504,7 @@ DECLARE_SOA_TABLE_FULL(StoredTracksCov, "TracksCov", "AOD", "TRACKCOV", //! On d
                        track::RhoZY, track::RhoSnpY, track::RhoSnpZ, track::RhoTglY, track::RhoTglZ,
                        track::RhoTglSnp, track::Rho1PtY, track::Rho1PtZ, track::Rho1PtSnp, track::Rho1PtTgl, o2::soa::Marker<1>);
 
-DECLARE_SOA_EXTENDED_TABLE(TracksCov, StoredTracksCov, "TRACKCOV", //! Track covariance matrix at collision vertex
+DECLARE_SOA_EXTENDED_TABLE(TracksCov, StoredTracksCov, "EXTRACKCOV", 0, //! Track covariance matrix at collision vertex
                            aod::track::CYY,
                            aod::track::CZY,
                            aod::track::CZZ,
@@ -531,7 +526,7 @@ DECLARE_SOA_TABLE_FULL(StoredTracksCovIU, "TracksCov_IU", "AOD", "TRACKCOV_IU",
                        track::RhoZY, track::RhoSnpY, track::RhoSnpZ, track::RhoTglY, track::RhoTglZ,
                        track::RhoTglSnp, track::Rho1PtY, track::Rho1PtZ, track::Rho1PtSnp, track::Rho1PtTgl, o2::soa::Marker<2>);
 
-DECLARE_SOA_EXTENDED_TABLE(TracksCovIU, StoredTracksCovIU, "TRACKCOV_IU", //! Track covariance matrix at inner most update (e.g. ITS) as it comes from the tracking
+DECLARE_SOA_EXTENDED_TABLE(TracksCovIU, StoredTracksCovIU, "EXTRACKCOV_IU", 0, //! Track covariance matrix at inner most update (e.g. ITS) as it comes from the tracking
                            aod::track::CYY,
                            aod::track::CZY,
                            aod::track::CZZ,
@@ -633,11 +628,11 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_002, "TracksExtra", "AOD", "T
                                  track::TPCFractionSharedCls<track::TPCNClsShared, track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
                                  track::TrackEtaEMCAL, track::TrackPhiEMCAL, track::TrackTime, track::TrackTimeRes);
 
-DECLARE_SOA_EXTENDED_TABLE(TracksExtra_000, StoredTracksExtra_000, "TRACKEXTRA", //! Additional track information (clusters, PID, etc.)
+DECLARE_SOA_EXTENDED_TABLE(TracksExtra_000, StoredTracksExtra_000, "EXTRACKEXTRA", 0, //! Additional track information (clusters, PID, etc.)
                            track::DetectorMap);
-DECLARE_SOA_EXTENDED_TABLE(TracksExtra_001, StoredTracksExtra_001, "TRACKEXTRA", //! Additional track information (clusters, PID, etc.)
+DECLARE_SOA_EXTENDED_TABLE(TracksExtra_001, StoredTracksExtra_001, "EXTRACKEXTRA", 1, //! Additional track information (clusters, PID, etc.)
                            track::v001::DetectorMap);
-DECLARE_SOA_EXTENDED_TABLE(TracksExtra_002, StoredTracksExtra_002, "TRACKEXTRA", //! Additional track information (clusters, PID, etc.)
+DECLARE_SOA_EXTENDED_TABLE(TracksExtra_002, StoredTracksExtra_002, "EXTRACKEXTRA", 2, //! Additional track information (clusters, PID, etc.)
                            track::v001::DetectorMap);
 
 DECLARE_SOA_TABLE(Run2TrackExtras, "AOD", "RUN2TRACKEXTRA",
@@ -656,9 +651,9 @@ using Run2TrackExtra = Run2TrackExtras::iterator;
 } // namespace aod
 namespace soa
 {
-extern template struct soa::Join<aod::Tracks, aod::TracksExtra>;
-extern template struct soa::Join<aod::Tracks, aod::TracksCov, aod::TracksExtra>;
-extern template struct soa::Join<aod::TracksExtension, aod::StoredTracks>;
+extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksExtra>;
+extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksCov, aod::TracksExtra>;
+extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::TracksExtension, aod::StoredTracks>;
 } // namespace soa
 namespace aod
 {
@@ -865,12 +860,12 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredMFTTracks_001, "MFTTracks", "AOD", "MFTTR
                                  fwdtrack::Sign<fwdtrack::Signed1Pt>, fwdtrack::Chi2,
                                  fwdtrack::TrackTime, fwdtrack::TrackTimeRes);
 
-DECLARE_SOA_EXTENDED_TABLE(MFTTracks_000, StoredMFTTracks_000, "MFTTRACK", //! Additional MFTTracks information (Pt, Eta, P), version 0
+DECLARE_SOA_EXTENDED_TABLE(MFTTracks_000, StoredMFTTracks_000, "EXMFTTRACK", 0, //! Additional MFTTracks information (Pt, Eta, P), version 0
                            aod::fwdtrack::Pt,
                            aod::fwdtrack::Eta,
                            aod::fwdtrack::P);
 
-DECLARE_SOA_EXTENDED_TABLE(MFTTracks_001, StoredMFTTracks_001, "MFTTRACK", //! Additional MFTTracks information (Pt, Eta, P), version 1
+DECLARE_SOA_EXTENDED_TABLE(MFTTracks_001, StoredMFTTracks_001, "EXMFTTRACK", 1, //! Additional MFTTracks information (Pt, Eta, P), version 1
                            aod::fwdtrack::Pt,
                            aod::fwdtrack::Eta,
                            aod::fwdtrack::P);
@@ -899,9 +894,9 @@ DECLARE_SOA_TABLE_FULL(StoredFwdTracks, "FwdTracks", "AOD", "FWDTRACK",
                        fwdtrack::MCHBitMap, fwdtrack::MIDBitMap, fwdtrack::MIDBoards,
                        fwdtrack::TrackTime, fwdtrack::TrackTimeRes);
 
-DECLARE_SOA_EXTENDED_TABLE(FwdTracks, StoredFwdTracks, "FWDTRACK", //!
-                           aod::fwdtrack::Eta,                     // NOTE the order is different here than in MFTTracks as table extension has to be unique
+DECLARE_SOA_EXTENDED_TABLE(FwdTracks, StoredFwdTracks, "EXFWDTRACK", 0, //!
                            aod::fwdtrack::Pt,
+                           aod::fwdtrack::Eta,
                            aod::fwdtrack::P);
 
 DECLARE_SOA_TABLE_FULL(StoredFwdTracksCov, "FwdTracksCov", "AOD", "FWDTRACKCOV", //!
@@ -909,7 +904,7 @@ DECLARE_SOA_TABLE_FULL(StoredFwdTracksCov, "FwdTracksCov", "AOD", "FWDTRACKCOV",
                        fwdtrack::RhoXY, fwdtrack::RhoPhiY, fwdtrack::RhoPhiX, fwdtrack::RhoTglX, fwdtrack::RhoTglY,
                        fwdtrack::RhoTglPhi, fwdtrack::Rho1PtX, fwdtrack::Rho1PtY, fwdtrack::Rho1PtPhi, fwdtrack::Rho1PtTgl);
 
-DECLARE_SOA_EXTENDED_TABLE(FwdTracksCov, StoredFwdTracksCov, "FWDTRACKCOV", //!
+DECLARE_SOA_EXTENDED_TABLE(FwdTracksCov, StoredFwdTracksCov, "EXFWDTRACKCOV", 0, //!
                            aod::fwdtrack::CXX,
                            aod::fwdtrack::CXY,
                            aod::fwdtrack::CYY,
@@ -932,7 +927,7 @@ using FwdTrackCovFwd = FwdTracksCov::iterator;
 } // namespace aod
 namespace soa
 {
-extern template struct Join<aod::FwdTracks, aod::FwdTracksCov>;
+extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::FwdTracks, aod::FwdTracksCov>;
 }
 namespace aod
 {
@@ -1653,13 +1648,13 @@ using TrackedV0 = TrackedV0s::iterator;
 using Tracked3Bodys = Tracked3Bodys;
 using Tracked3body = Tracked3Bodys::iterator;
 
-namespace origin
+namespace origins
 {
 DECLARE_SOA_COLUMN(DataframeID, dataframeID, uint64_t); //! Data frame ID (what is usually found in directory name in the AO2D.root, i.e. DF_XXX)
 } // namespace origin
 
 DECLARE_SOA_TABLE(Origins, "AOD", "ORIGIN", //! Table which contains the IDs of all dataframes merged into this dataframe
-                  o2::soa::Index<>, origin::DataframeID);
+                  o2::soa::Index<>, origins::DataframeID);
 
 using Origin = Origins::iterator;
 
@@ -1826,14 +1821,14 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredMcParticles_001, "McParticles", "AOD", "M
                                  mcparticle::GetProcess<mcparticle::Flags, mcparticle::StatusCode>,
                                  mcparticle::IsPhysicalPrimary<mcparticle::Flags>);
 
-DECLARE_SOA_EXTENDED_TABLE(McParticles_000, StoredMcParticles_000, "MCPARTICLE", //! Basic MC particle properties
+DECLARE_SOA_EXTENDED_TABLE(McParticles_000, StoredMcParticles_000, "EXMCPARTICLE", 0, //! Basic MC particle properties
                            mcparticle::Phi,
                            mcparticle::Eta,
                            mcparticle::Pt,
                            mcparticle::P,
                            mcparticle::Y);
 
-DECLARE_SOA_EXTENDED_TABLE(McParticles_001, StoredMcParticles_001, "MCPARTICLE", //! Basic MC particle properties
+DECLARE_SOA_EXTENDED_TABLE(McParticles_001, StoredMcParticles_001, "EXMCPARTICLE", 1, //! Basic MC particle properties
                            mcparticle::Phi,
                            mcparticle::Eta,
                            mcparticle::Pt,
@@ -1846,18 +1841,16 @@ using McParticle = McParticles::iterator;
 } // namespace aod
 namespace soa
 {
-DECLARE_EQUIVALENT_FOR_INDEX(aod::Collisions_000, aod::Collisions_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredMcParticles_000, aod::StoredMcParticles_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracks, aod::StoredTracksIU);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracks, aod::StoredTracksExtra_000);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracksIU, aod::StoredTracksExtra_000);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracks, aod::StoredTracksExtra_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracksIU, aod::StoredTracksExtra_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracksExtra_000, aod::StoredTracksExtra_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::HMPID_000, aod::HMPID_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredMFTTracks, aod::StoredMFTTracks_000);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredMFTTracks, aod::StoredMFTTracks_001);
-DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredMFTTracks_000, aod::StoredMFTTracks_001);
+DECLARE_EQUIVALENT_FOR_INDEX_NG("COLLISION/0", "COLLISION/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("MCPARTICLE/0", "MCPARTICLE/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACK/0", "TRACK_IU/0");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACK/0", "TRACKEXTRA/0");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACK_IU/0", "TRACKEXTRA/0");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACK/0", "TRACKEXTRA/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACK_IU/0", "TRACKEXTRA/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("TRACKEXTRA/0", "TRACKEXTRA/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("HMPID/0", "HMPID/1");
+DECLARE_EQUIVALENT_FOR_INDEX_NG("MFTTracks/0", "MFTTracks/1");
 } // namespace soa
 
 namespace aod
@@ -2040,8 +2033,8 @@ DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracksIU, aod::McTrackLabels);
 DECLARE_EQUIVALENT_FOR_INDEX(aod::Collisions, aod::McCollisionLabels);
 // Joins with collisions (only for sparse ones)
 // NOTE: index table needs to be always last argument
-extern template struct Join<aod::Collisions, aod::Run2MatchedSparse>;
-extern template struct Join<aod::Collisions, aod::Run3MatchedSparse>;
+extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run2MatchedSparse>;
+extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run3MatchedSparse>;
 } // namespace soa
 namespace aod
 {
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 7ec62f3bef391..d84c9714b2f30 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -11,41 +11,91 @@
 #ifndef o2_framework_AnalysisHelpers_H_DEFINED
 #define o2_framework_AnalysisHelpers_H_DEFINED
 
-#include "Framework/DataAllocator.h"
-#include "Framework/Traits.h"
-#include "Framework/TableBuilder.h"
 #include "Framework/ASoA.h"
-#include "Framework/OutputSpec.h"
-#include "Framework/OutputRef.h"
+#include "Framework/DataAllocator.h"
+#include "Framework/ExpressionHelpers.h"
+#include "Framework/IndexBuilderHelpers.h"
 #include "Framework/InputSpec.h"
-#include "Framework/OutputObjHeader.h"
-#include "Framework/StringHelpers.h"
 #include "Framework/Output.h"
-#include "Framework/IndexBuilderHelpers.h"
+#include "Framework/OutputObjHeader.h"
+#include "Framework/OutputRef.h"
+#include "Framework/OutputSpec.h"
 #include "Framework/Plugins.h"
-#include "Framework/ExpressionHelpers.h"
+#include "Framework/StringHelpers.h"
+#include "Framework/TableBuilder.h"
+#include "Framework/Traits.h"
 
 #include <string>
+namespace o2::soa
+{
+template <TableRef R>
+constexpr auto tableRef2InputSpec()
+{
+  return framework::InputSpec{
+    o2::aod::label<R>(),
+    o2::aod::origin<R>(),
+    o2::aod::description(o2::aod::signature<R>()),
+    R.version};
+}
+
+template <TableRef R>
+constexpr auto tableRef2OutputSpec()
+{
+  return framework::OutputSpec{
+    framework::OutputLabel{o2::aod::label<R>()},
+    o2::aod::origin<R>(),
+    o2::aod::description(o2::aod::signature<R>()),
+    R.version};
+}
+
+template <TableRef R>
+constexpr auto tableRef2Output()
+{
+  return framework::Output{
+    o2::aod::origin<R>(),
+    o2::aod::description(o2::aod::signature<R>()),
+    R.version};
+}
+
+template <TableRef R>
+constexpr auto tableRef2OutputRef()
+{
+  return framework::OutputRef{
+    o2::aod::label<R>(),
+    R.version};
+}
+
+template <TableRef R>
+constexpr auto tableRef2ConfigParamSpec()
+{
+  return o2::framework::ConfigParamSpec{
+    std::string{"input:"} + o2::aod::label<R>(),
+    framework::VariantType::String,
+    aod::sourceSpec<R>(),
+    {"\"\""}};
+}
+}  // namespace o2::soa
+
 namespace o2::framework
 {
 class TableConsumer;
 
-template <typename T>
-struct WritingCursor {
-  static_assert(always_static_assert_v<T>, "Type must be a o2::soa::Table");
-};
 /// Helper class actually implementing the cursor which can write to
 /// a table. The provided template arguments are if type Column and
 /// therefore refer only to the persisted columns.
-template <o2::framework::OriginEnc ORIGIN, typename... PC>
-struct WritingCursor<soa::Table<ORIGIN, PC...>> {
-  using persistent_table_t = soa::Table<ORIGIN, PC...>;
+template <typename T>
+concept is_producable = soa::has_metadata<aod::MetadataTrait<T>> || soa::has_metadata<aod::MetadataTrait<typename T::parent_t>>;
+
+template <is_producable T>
+struct WritingCursor {
+ public:
+  using persistent_table_t = decltype([]() { if constexpr (soa::is_iterator<T>) { return typename T::parent_t{nullptr}; } else { return T{nullptr}; } }());
   using cursor_t = decltype(std::declval<TableBuilder>().cursor<persistent_table_t>());
 
-  template <typename... T>
-  void operator()(T... args)
+  template <typename... Ts>
+  void operator()(Ts... args)
   {
-    static_assert(sizeof...(PC) == sizeof...(T), "Argument number mismatch");
+    static_assert(sizeof...(Ts) == framework::pack_size(typename persistent_table_t::persistent_columns_t{}), "Argument number mismatch");
     ++mCount;
     cursor(0, extract(args)...);
   }
@@ -84,15 +134,17 @@ struct WritingCursor<soa::Table<ORIGIN, PC...>> {
   decltype(FFL(std::declval<cursor_t>())) cursor;
 
  private:
-  template <typename T>
-  static decltype(auto) extract(T const& arg)
+  template <typename A>
+    requires requires { &A::globalIndex; }
+  static decltype(auto) extract(A const& arg)
   {
-    if constexpr (requires(T t) { t.globalIndex(); }) {
-      return arg.globalIndex();
-    } else {
-      static_assert(!framework::has_type<T>(framework::pack<PC...>{}), "Argument type mismatch");
-      return arg;
-    }
+    return arg.globalIndex();
+  }
+
+  template <typename A>
+  static decltype(auto) extract(A const& arg)
+  {
+    return arg;
   }
 
   /// The table builder which actually performs the
@@ -103,20 +155,30 @@ struct WritingCursor<soa::Table<ORIGIN, PC...>> {
 };
 
 /// Helper to define output for a Table
+template <soa::is_table T>
+consteval auto typeWithRef() -> T
+{
+}
+
+template <soa::is_iterator T>
+consteval auto typeWithRef() -> typename T::parent_t
+{
+}
+
 template <typename T>
   requires soa::is_table<T> || soa::is_iterator<T>
 struct OutputForTable {
-  using table_t = T;
-  using metadata = typename aod::MetadataTrait<table_t>::metadata;
+  using table_t = decltype(typeWithRef<T>());
+  using metadata = aod::MetadataTrait<o2::aod::Hash<table_t::ref.desc_hash>>::metadata;
 
   static OutputSpec const spec()
   {
-    return OutputSpec{OutputLabel{metadata::tableLabel()}, metadata::origin(), metadata::description(), metadata::version()};
+    return OutputSpec{OutputLabel{aod::label<table_t::ref>()}, o2::aod::origin<table_t::ref>(), o2::aod::description(o2::aod::signature<table_t::ref>()), table_t::ref.version};
   }
 
   static OutputRef ref()
   {
-    return OutputRef{metadata::tableLabel(), metadata::version()};
+    return OutputRef{aod::label<table_t::ref>(), table_t::ref.version};
   }
 };
 
@@ -124,12 +186,8 @@ struct OutputForTable {
 /// given analysis task. Notice how the actual cursor is implemented by the
 /// means of the WritingCursor helper class, from which produces actually
 /// derives.
-template <typename T>
-requires(!std::is_same_v<void, typename aod::MetadataTrait<T>::metadata>) struct Produces : WritingCursor<typename soa::PackToTable<aod::MetadataTrait<T>::metadata::origin(), typename T::table_t::persistent_columns_t>::table> {
-};
-
-template <template <o2::framework::OriginEnc, typename...> class T, o2::framework::OriginEnc ORIGIN, typename... C>
-struct Produces<T<ORIGIN, C...>> : WritingCursor<typename soa::PackToTable<ORIGIN, typename T<ORIGIN, C...>::table_t::persistent_columns_t>::table> {
+template <is_producable T>
+struct Produces : WritingCursor<T> {
 };
 
 /// Use this to group together produces. Useful to separate them logically
@@ -144,69 +202,58 @@ struct ProducesGroup {
 };
 
 /// Helper template for table transformations
-template <typename METADATA>
+template <soa::is_metadata M, soa::TableRef Ref>
 struct TableTransform {
-  using SOURCES = typename METADATA::sources;
-  using ORIGINALS = typename METADATA::originals;
-
-  using metadata = METADATA;
-  using sources = SOURCES;
-
-  constexpr auto sources_pack() const
-  {
-    return SOURCES{};
-  }
-
-  constexpr auto originals_pack() const
-  {
-    return ORIGINALS{};
-  }
+  using metadata = M;
+  constexpr static auto sources = M::sources;
 
-  template <typename Oi>
-  constexpr auto base_spec() const
+  template <soa::TableRef R>
+  static constexpr auto base_spec()
   {
-    using o_metadata = typename aod::MetadataTrait<Oi>::metadata;
-    return InputSpec{
-      o_metadata::tableLabel(),
-      header::DataOrigin{o_metadata::origin()},
-      header::DataDescription{o_metadata::description()},
-      o_metadata::version()};
+    return soa::tableRef2InputSpec<R>();
   }
 
-  template <typename... Os>
-  std::vector<InputSpec> base_specs_impl(framework::pack<Os...>) const
+  static auto base_specs()
   {
-    return {base_spec<Os>()...};
-  }
-
-  std::vector<InputSpec> base_specs() const
-  {
-    return base_specs_impl(sources_pack());
+    return []<size_t... Is>(std::index_sequence<Is...>) -> std::vector<InputSpec> {
+      return {base_spec<sources[Is]>()...};
+    }(std::make_index_sequence<sources.size()>{});
   }
 
   constexpr auto spec() const
   {
-    return OutputSpec{OutputLabel{METADATA::tableLabel()}, METADATA::origin(), METADATA::description(), METADATA::version()};
+    return soa::tableRef2OutputSpec<Ref>();
   }
 
   constexpr auto output() const
   {
-    return Output{METADATA::origin(), METADATA::description(), METADATA::version()};
+    return soa::tableRef2Output<Ref>();
   }
 
   constexpr auto ref() const
   {
-    return OutputRef{METADATA::tableLabel(), METADATA::version()};
+    return soa::tableRef2OutputRef<Ref>();
   }
 };
 
 /// This helper struct allows you to declare extended tables which should be
 /// created by the task (as opposed to those pre-defined by data model)
 template <typename T>
-struct Spawns : TableTransform<typename aod::MetadataTrait<framework::pack_head_t<typename T::originals>>::metadata> {
-  using extension_t = framework::pack_head_t<typename T::originals>;
-  using base_table_t = typename aod::MetadataTrait<extension_t>::metadata::base_table_t;
-  using expression_pack_t = typename aod::MetadataTrait<extension_t>::metadata::expression_pack_t;
+concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata>;
+
+template <is_spawnable T>
+constexpr auto transformBase()
+{
+  using metadata = typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata;
+  return TableTransform<metadata, metadata::extension_table_t::ref>{};
+}
+
+template <is_spawnable T>
+struct Spawns : decltype(transformBase<T>()) {
+  using metadata = decltype(transformBase<T>())::metadata;
+  using extension_t = typename metadata::extension_table_t;
+  using base_table_t = typename metadata::base_table_t;
+  using expression_pack_t = typename metadata::expression_pack_t;
 
   constexpr auto pack()
   {
@@ -254,9 +301,9 @@ struct ColumnTrait {
 
   static consteval auto listSize()
   {
-    if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
+    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
       return -1;
-    } else if constexpr (std::is_same_v<int[2], typename C::type>) {
+    } else if constexpr (std::same_as<int[2], typename C::type>) {
       return 2;
     } else {
       return 1;
@@ -266,7 +313,7 @@ struct ColumnTrait {
   template <typename T, typename Key>
   static std::shared_ptr<SelfIndexColumnBuilder> makeColumnBuilder(arrow::Table* table, arrow::MemoryPool* pool)
   {
-    if constexpr (!std::is_same_v<T, Key>) {
+    if constexpr (!std::same_as<T, Key>) {
       return std::make_shared<IndexColumnBuilder>(getIndexToKey<T, Key>(table), C::columnLabel(), listSize(), pool);
     } else {
       return std::make_shared<SelfIndexColumnBuilder>(C::columnLabel(), pool);
@@ -278,70 +325,107 @@ template <typename Key, typename C>
 struct Reduction {
   using type = typename std::conditional<soa::is_binding_compatible_v<Key, typename C::binding_t>(), SelfIndexColumnBuilder, IndexColumnBuilder>::type;
 };
-} // namespace
+
+template <typename Key, typename C>
+using reduced_t = Reduction<Key, C>::type;
+}  // namespace
 
 template <typename Kind>
 struct IndexBuilder {
-  template <typename Key, typename C1, typename... Cs, typename T1, typename... Ts>
-  static auto indexBuilder(const char* label, std::vector<std::shared_ptr<arrow::Table>>&& tables, framework::pack<C1, Cs...>, framework::pack<T1, Ts...>)
+  template <typename Key, size_t N, std::array<soa::TableRef, N> refs, typename C1, typename... Cs>
+  static auto indexBuilder(const char* label, std::vector<std::shared_ptr<arrow::Table>>&& tables, framework::pack<C1, Cs...>)
   {
     auto pool = arrow::default_memory_pool();
     SelfIndexColumnBuilder self{C1::columnLabel(), pool};
     std::unique_ptr<ChunkedArrayIterator> keyIndex = nullptr;
-    int64_t counter = 0;
-    if constexpr (!std::is_same_v<T1, Key>) {
-      keyIndex = std::make_unique<ChunkedArrayIterator>(getIndexToKey<T1, Key>(tables[0].get()));
+    if constexpr (!Key::template hasOriginal<refs[0]>()) {
+      keyIndex = std::make_unique<ChunkedArrayIterator>(tables[0]->column(o2::aod::MetadataTrait<o2::aod::Hash<refs[0].desc_hash>>::metadata::template getIndexPosToKey<Key>()));
+    }
+
+    auto sq = std::make_index_sequence<sizeof...(Cs)>();
+
+    auto columnBuilders = [&tables, &pool ]<size_t... Is>(std::index_sequence<Is...>) -> std::array<std::shared_ptr<framework::SelfIndexColumnBuilder>, sizeof...(Cs)>
+    {
+      return {[](arrow::Table* table, arrow::MemoryPool* pool) {
+        using T = framework::pack_element_t<Is, framework::pack<Cs...>>;
+        if constexpr (!Key::template hasOriginal<refs[Is + 1]>()) {
+          constexpr auto pos = o2::aod::MetadataTrait<o2::aod::Hash<refs[Is + 1].desc_hash>>::metadata::template getIndexPosToKey<Key>();
+          return std::make_shared<IndexColumnBuilder>(table->column(pos), T::columnLabel(), ColumnTrait<T>::listSize(), pool);
+        } else {
+          return std::make_shared<SelfIndexColumnBuilder>(T::columnLabel(), pool);
+        }
+      }(tables[Is + 1].get(), pool)...};
     }
+    (sq);
 
-    std::array<std::shared_ptr<framework::SelfIndexColumnBuilder>, sizeof...(Cs)> columnBuilders{ColumnTrait<Cs>::template makeColumnBuilder<framework::pack_element_t<framework::has_type_at_v<Cs>(framework::pack<Cs...>{}), framework::pack<Ts...>>, Key>(
-      tables[framework::has_type_at_v<Cs>(framework::pack<Cs...>{}) + 1].get(),
-      pool)...};
     std::array<bool, sizeof...(Cs)> finds;
 
-    for (counter = 0; counter < tables[0]->num_rows(); ++counter) {
-      auto idx = -1;
-      if constexpr (std::is_same_v<T1, Key>) {
+    for (int64_t counter = 0; counter < tables[0]->num_rows(); ++counter) {
+      int64_t idx = -1;
+      if constexpr (Key::template hasOriginal<refs[0]>()) {
         idx = counter;
       } else {
         idx = keyIndex->valueAt(counter);
       }
-      finds = {std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template find<Cs>(idx)...};
-      if constexpr (std::is_same_v<Kind, Sparse>) {
-        (std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx), ...);
+      finds = [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
+        return std::array{
+          [&idx, &columnBuilders]() {
+            using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
+            return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template find<T>(idx);
+          }()...};
+      }(sq);
+      if constexpr (std::same_as<Kind, Sparse>) {
+        [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
+          ([&idx, &columnBuilders]() {
+            using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
+            return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template fill<T>(idx); }(), ...);
+        }(sq);
         self.fill<C1>(counter);
-      } else if constexpr (std::is_same_v<Kind, Exclusive>) {
+      } else if constexpr (std::same_as<Kind, Exclusive>) {
         if (std::none_of(finds.begin(), finds.end(), [](bool const x) { return x == false; })) {
-          (std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template fill<Cs>(idx), ...);
+          [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
+            ([&idx, &columnBuilders]() {
+              using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
+              return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template fill<T>(idx);
+            }(),
+             ...);
+          }(sq);
           self.fill<C1>(counter);
         }
       }
     }
 
-    return makeArrowTable(label,
-                          {self.template result<C1>(), std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->template result<Cs>()...},
-                          {self.field(), std::static_pointer_cast<typename Reduction<Key, Cs>::type>(columnBuilders[framework::has_type_at_v<Cs>(framework::pack<Cs...>{})])->field()...});
-  }
-
-  template <typename IDX, typename Key, typename T1, typename... T>
-  static auto makeIndex(Key const& key, std::tuple<T1, T...>&& tables)
-  {
-    auto t = IDX{indexBuilder(o2::aod::MetadataTrait<IDX>::metadata::tableLabel(),
-                              typename o2::aod::MetadataTrait<IDX>::metadata::index_pack_t{},
-                              key,
-                              std::make_tuple(std::decay_t<T1>{{std::get<T1>(tables)}}, std::decay_t<T>{{std::get<T>(tables)}}...))};
-    t.bindExternalIndices(&key, &std::get<T1>(tables), &std::get<T>(tables)...);
-    return t;
+    return [&label, &columnBuilders, &self]<size_t... Is>(std::index_sequence<Is...>) {
+      return makeArrowTable(label,
+                            {self.template result<C1>(), [&columnBuilders]() {
+                               using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
+                               return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template result<T>();
+                             }()...},
+                            {self.field(), [&columnBuilders]() {
+                               using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
+                               return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->field();
+                             }()...});
+    }(sq);
   }
 };
 
 /// This helper struct allows you to declare index tables to be created in a task
-template <typename T>
-struct Builds : TableTransform<typename aod::MetadataTrait<T>::metadata> {
-  using IP = std::conditional_t<aod::MetadataTrait<T>::metadata::exclusive, IndexBuilder<Exclusive>, IndexBuilder<Sparse>>;
-  using Key = typename T::indexing_t;
+
+template <soa::is_index_table T>
+constexpr auto transformBase()
+{
+  using metadata = typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata;
+  return TableTransform<metadata, T::ref>{};
+}
+
+template <soa::is_index_table T>
+struct Builds : decltype(transformBase<T>()) {
+  using metadata = decltype(transformBase<T>())::metadata;
+  using IP = std::conditional_t<metadata::exclusive, IndexBuilder<Exclusive>, IndexBuilder<Sparse>>;
+  using Key = metadata::Key;
   using H = typename T::first_t;
   using Ts = typename T::rest_t;
-  using index_pack_t = typename aod::MetadataTrait<T>::metadata::index_pack_t;
+  using index_pack_t = metadata::index_pack_t;
 
   T* operator->()
   {
@@ -363,10 +447,10 @@ struct Builds : TableTransform<typename aod::MetadataTrait<T>::metadata> {
     return index_pack_t{};
   }
 
-  template <typename Key, typename... Cs, typename... Ts>
-  auto build(framework::pack<Cs...>, framework::pack<Ts...>, std::vector<std::shared_ptr<arrow::Table>>&& tables)
+  template <typename Key, typename... Cs>
+  auto build(framework::pack<Cs...>, std::vector<std::shared_ptr<arrow::Table>>&& tables)
   {
-    this->table = std::make_shared<T>(IP::template indexBuilder<Key>(aod::MetadataTrait<T>::metadata::tableLabel(), std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables), framework::pack<Cs...>{}, framework::pack<Ts...>{}));
+    this->table = std::make_shared<T>(IP::template indexBuilder<Key, metadata::sources.size(), metadata::sources>(o2::aod::label<T::ref>(), std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables), framework::pack<Cs...>{}));
     return (this->table != nullptr);
   }
 };
@@ -475,7 +559,7 @@ struct Service {
 
   decltype(auto) operator->() const
   {
-    if constexpr (is_base_of_template_v<LoadableServicePlugin, T>) {
+    if constexpr (base_of_template<LoadableServicePlugin, T>) {
       return service->get();
     } else {
       return service;
@@ -606,7 +690,7 @@ struct Partition {
     return mFiltered->size();
   }
 };
-} // namespace o2::framework
+}  // namespace o2::framework
 
 namespace o2::soa
 {
@@ -614,8 +698,8 @@ namespace o2::soa
 template <soa::is_table T, soa::is_spawnable_column... Cs>
 auto Extend(T const& table)
 {
-  using output_t = Join<T, soa::Table<o2::framework::OriginEnc{"JOIN"}, Cs...>>;
-  return output_t{{o2::framework::spawner<o2::framework::OriginEnc{"JOIN"}>(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension"), table.asArrowTable()}, 0};
+  using output_t = Join<T, soa::Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Cs...>>;
+  return output_t{{o2::framework::spawner(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension"), table.asArrowTable()}, 0};
 }
 
 /// Template function to attach dynamic columns on-the-fly (e.g. inside
@@ -623,9 +707,9 @@ auto Extend(T const& table)
 template <soa::is_table T, soa::is_dynamic_column... Cs>
 auto Attach(T const& table)
 {
-  using output_t = Join<T, o2::soa::Table<o2::framework::OriginEnc{"JOIN"}, Cs...>>;
+  using output_t = Join<T, o2::soa::Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Cs...>>;
   return output_t{{table.asArrowTable()}, table.offset()};
 }
-} // namespace o2::soa
+}  // namespace o2::soa
 
-#endif // o2_framework_AnalysisHelpers_H_DEFINED
+#endif  // o2_framework_AnalysisHelpers_H_DEFINED
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index ca84d07110073..e0dd21708e841 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -24,12 +24,8 @@
 #include "Framework/ConfigurableHelpers.h"
 #include "Framework/Condition.h"
 #include "Framework/InitContext.h"
-#include "Framework/ConfigContext.h"
 #include "Framework/RootConfigParamHelpers.h"
-#include "Framework/ExpressionHelpers.h"
-#include "Framework/CommonServices.h"
 #include "Framework/PluginManager.h"
-#include "Framework/RootMessageContext.h"
 #include "Framework/DeviceSpec.h"
 
 namespace o2::framework
@@ -49,7 +45,7 @@ struct GroupedCombinationManager<GroupedCombinationsGenerator<T1, GroupingPolicy
   static void setGroupedCombination(GroupedCombinationsGenerator<T1, GroupingPolicy, BP, G, As...>& comb, TG& grouping, std::tuple<T2s...>& associated)
   {
     static_assert(sizeof...(T2s) > 0, "There must be associated tables in process() for a correct pair");
-    if constexpr (std::is_same_v<G, TG>) {
+    if constexpr (std::same_as<G, TG>) {
       static_assert((framework::has_type<As>(pack<T2s...>{}) && ...), "You didn't subscribed to all tables requested for mixing");
       comb.setTables(grouping, associated);
     }
@@ -93,7 +89,7 @@ struct PartitionManager<Partition<T>> {
   template <typename T2>
   static void doSetPartition(Partition<T>& partition, T2& table)
   {
-    if constexpr (std::is_same_v<T, T2>) {
+    if constexpr (std::same_as<T, T2>) {
       partition.bindTable(table);
     }
   }
@@ -164,7 +160,7 @@ struct ConditionManager {
   template <typename ANY>
   static bool appendCondition(std::vector<InputSpec>& inputs, ANY& x)
   {
-    if constexpr (std::is_base_of_v<ConditionGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ConditionGroup>) {
       homogeneous_apply_refs<true>([&inputs](auto& y) { return ConditionManager<std::decay_t<decltype(y)>>::appendCondition(inputs, y); }, x);
       return true;
     } else {
@@ -175,7 +171,7 @@ struct ConditionManager {
   template <typename ANY>
   static bool newDataframe(InputRecord& record, ANY& x)
   {
-    if constexpr (std::is_base_of_v<ConfigurableGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ConfigurableGroup>) {
       homogeneous_apply_refs<true>([&record](auto&& y) { return ConditionManager<std::decay_t<decltype(y)>>::newDataframe(record, y); }, x);
       return true;
     } else {
@@ -204,7 +200,7 @@ struct OutputManager {
   template <typename ANY>
   static bool appendOutput(std::vector<OutputSpec>& outputs, ANY& what, uint32_t v)
   {
-    if constexpr (std::is_base_of_v<ProducesGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ProducesGroup>) {
       homogeneous_apply_refs<true>([&outputs, v](auto& p) { return OutputManager<std::decay_t<decltype(p)>>::appendOutput(outputs, p, v); }, what);
       return true;
     }
@@ -214,7 +210,7 @@ struct OutputManager {
   template <typename ANY>
   static bool prepare(ProcessingContext& context, ANY& what)
   {
-    if constexpr (std::is_base_of_v<ProducesGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ProducesGroup>) {
       homogeneous_apply_refs<true>([&context](auto& p) { return OutputManager<std::decay_t<decltype(p)>>::prepare(context, p); }, what);
       return true;
     }
@@ -224,7 +220,7 @@ struct OutputManager {
   template <typename ANY>
   static bool postRun(EndOfStreamContext& context, ANY& what)
   {
-    if constexpr (std::is_base_of_v<ProducesGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ProducesGroup>) {
       homogeneous_apply_refs<true>([&context](auto& p) { return OutputManager<std::decay_t<decltype(p)>>::postRun(context, p); }, what);
       return true;
     }
@@ -234,7 +230,7 @@ struct OutputManager {
   template <typename ANY>
   static bool finalize(ProcessingContext& context, ANY& what)
   {
-    if constexpr (std::is_base_of_v<ProducesGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ProducesGroup>) {
       homogeneous_apply_refs<true>([&context](auto& p) { return OutputManager<std::decay_t<decltype(p)>>::finalize(context, p); }, what);
       return true;
     }
@@ -243,25 +239,25 @@ struct OutputManager {
 };
 
 /// Produces specialization
-template <typename TABLE>
-struct OutputManager<Produces<TABLE>> {
-  static bool appendOutput(std::vector<OutputSpec>& outputs, Produces<TABLE>& /*what*/, uint32_t)
+template <is_producable T>
+struct OutputManager<Produces<T>> {
+  static bool appendOutput(std::vector<OutputSpec>& outputs, Produces<T>& /*what*/, uint32_t)
   {
-    outputs.emplace_back(OutputForTable<TABLE>::spec());
+    outputs.emplace_back(OutputForTable<typename Produces<T>::persistent_table_t>::spec());
     return true;
   }
-  static bool prepare(ProcessingContext& context, Produces<TABLE>& what)
+  static bool prepare(ProcessingContext& context, Produces<T>& what)
   {
-    what.resetCursor(std::move(context.outputs().make<TableBuilder>(OutputForTable<TABLE>::ref())));
+    what.resetCursor(std::move(context.outputs().make<TableBuilder>(OutputForTable<typename Produces<T>::persistent_table_t>::ref())));
     return true;
   }
-  static bool finalize(ProcessingContext&, Produces<TABLE>& what)
+  static bool finalize(ProcessingContext&, Produces<T>& what)
   {
-    what.setLabel(o2::aod::MetadataTrait<TABLE>::metadata::tableLabel());
+    what.setLabel(o2::aod::label<Produces<T>::persistent_table_t::ref>());
     what.release();
     return true;
   }
-  static bool postRun(EndOfStreamContext&, Produces<TABLE>&)
+  static bool postRun(EndOfStreamContext&, Produces<T>&)
   {
     return true;
   }
@@ -335,7 +331,15 @@ static inline std::vector<std::shared_ptr<arrow::Table>> extractOriginals(framew
   return {extractOriginal<Os>(pc)...};
 }
 
-template <typename T>
+template <size_t N, std::array<soa::TableRef, N> refs>
+static inline auto extractOriginals(ProcessingContext& pc)
+{
+  return [&]<size_t... Is>(std::index_sequence<Is...>) -> std::vector<std::shared_ptr<arrow::Table>> {
+    return {pc.inputs().get<TableConsumer>(o2::aod::label<refs[Is]>())->asArrowTable()...};
+  }(std::make_index_sequence<refs.size()>());
+}
+
+template <is_spawnable T>
 struct OutputManager<Spawns<T>> {
   static bool appendOutput(std::vector<OutputSpec>& outputs, Spawns<T>& what, uint32_t)
   {
@@ -345,13 +349,14 @@ struct OutputManager<Spawns<T>> {
 
   static bool prepare(ProcessingContext& pc, Spawns<T>& what)
   {
-    auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals(what.sources_pack(), pc));
+    using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata;
+    auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(pc));
     if (originalTable->schema()->fields().empty() == true) {
       using base_table_t = typename Spawns<T>::base_table_t::table_t;
-      originalTable = makeEmptyTable<base_table_t>(aod::MetadataTrait<typename Spawns<T>::extension_t>::metadata::tableLabel());
+      originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
     }
 
-    what.extension = std::make_shared<typename Spawns<T>::extension_t>(o2::framework::spawner<aod::MetadataTrait<typename Spawns<T>::extension_t>::metadata::origin()>(what.pack(), extractOriginals(what.sources_pack(), pc), aod::MetadataTrait<typename Spawns<T>::extension_t>::metadata::tableLabel()));
+    what.extension = std::make_shared<typename Spawns<T>::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>()));
     what.table = std::make_shared<typename T::table_t>(soa::ArrowHelpers::joinTables({what.extension->asArrowTable(), originalTable}));
     return true;
   }
@@ -379,19 +384,13 @@ static inline auto doExtractOriginal(framework::pack<Ts...>, ProcessingContext&
   }
 }
 
-template <typename O>
-static inline auto extractOriginalJoined(ProcessingContext& pc)
-{
-  return o2::soa::ArrowHelpers::joinTables({doExtractOriginal(soa::make_originals_from_type<O>(), pc)});
-}
-
 template <typename... Os>
 static inline auto extractOriginalsVector(framework::pack<Os...>, ProcessingContext& pc)
 {
   return std::vector{extractOriginalJoined<Os>(pc)...};
 }
 
-template <typename T>
+template <soa::is_index_table T>
 struct OutputManager<Builds<T>> {
   static bool appendOutput(std::vector<OutputSpec>& outputs, Builds<T>& what, uint32_t)
   {
@@ -401,8 +400,8 @@ struct OutputManager<Builds<T>> {
 
   static bool prepare(ProcessingContext& pc, Builds<T>& what)
   {
-    return what.template build<typename T::indexing_t>(what.pack(), what.originals_pack(),
-                                                       extractOriginalsVector(what.originals_pack(), pc));
+    using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata;
+    return what.template build<typename T::indexing_t>(what.pack(), extractOriginals<metadata::sources.size(), metadata::sources>(pc));
   }
 
   static bool finalize(ProcessingContext& pc, Builds<T>& what)
@@ -420,7 +419,7 @@ struct OutputManager<Builds<T>> {
 template <typename T>
 struct ServiceManager {
   template <typename ANY>
-  static bool add(std::vector<ServiceSpec>& specs, ANY& any)
+  static bool add(std::vector<ServiceSpec>& /*specs*/, ANY& /*any*/)
   {
     return false;
   }
@@ -442,7 +441,7 @@ template <typename T>
 struct ServiceManager<Service<T>> {
   static bool add(std::vector<ServiceSpec>& specs, Service<T>& /*service*/)
   {
-    if constexpr (o2::framework::is_base_of_template_v<LoadableServicePlugin, T>) {
+    if constexpr (o2::framework::base_of_template<LoadableServicePlugin, T>) {
       T p = T{};
       auto loadableServices = PluginManager::parsePluginSpecString(p.loadSpec.c_str());
       PluginManager::loadFromPlugin<ServiceSpec, ServicePlugin>(loadableServices, specs);
@@ -510,7 +509,7 @@ struct OptionManager {
   static bool appendOption(std::vector<ConfigParamSpec>& options, ANY& x)
   {
     /// Recurse, in case we are brace constructible
-    if constexpr (std::is_base_of_v<ConfigurableGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ConfigurableGroup>) {
       if constexpr (requires { x.prefix; }) {
         homogeneous_apply_refs<true>([prefix = x.prefix]<typename C>(C& y) { // apend group prefix if set
           if constexpr (requires { y.name; }) {
@@ -531,7 +530,7 @@ struct OptionManager {
   template <typename ANY>
   static bool prepare(InitContext& ic, ANY& x)
   {
-    if constexpr (std::is_base_of_v<ConfigurableGroup, ANY>) {
+    if constexpr (std::derived_from<ANY, ConfigurableGroup>) {
       homogeneous_apply_refs<true>([&ic](auto&& y) { return OptionManager<std::decay_t<decltype(y)>>::prepare(ic, y); }, x);
       return true;
     } else {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 64bf7c98051e2..cf0bba20e74ea 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -76,21 +76,24 @@ struct AnalysisDataProcessorBuilder {
     }
   }
 
-  template <typename... T>
-  static inline std::vector<ConfigParamSpec> getInputSpecs(framework::pack<T...>)
+  template <soa::TableRef R>
+  static ConfigParamSpec getSpec()
   {
-    return std::vector{getSpec<T>()...};
+    return soa::tableRef2ConfigParamSpec<R>();
   }
 
-  template <typename T>
-    requires soa::has_sources<typename o2::aod::MetadataTrait<std::decay_t<T>>::metadata>
+  template <soa::with_sources T>
   static inline auto getSources()
   {
-    return getInputSpecs(typename aod::MetadataTrait<std::decay_t<T>>::metadata::sources{});
+    return []<size_t N, std::array<soa::TableRef, N> refs>() {
+      return []<size_t... Is>(std::index_sequence<Is...>) {
+        return std::vector{soa::tableRef2ConfigParamSpec<refs[Is]>()...};
+      }(std::make_index_sequence<N>());
+    }.template operator()<T::sources.size(), T::sources>();
   }
 
-  template <typename T>
-    requires soa::has_sources<typename o2::aod::MetadataTrait<std::decay_t<T>>::metadata>
+  template <soa::with_sources T>
+
   static auto getInputMetadata()
   {
     std::vector<ConfigParamSpec> inputMetadata;
@@ -106,11 +109,14 @@ struct AnalysisDataProcessorBuilder {
   static void addGroupingCandidates(std::vector<StringPair>& bk, std::vector<StringPair>& bku)
   {
     [&bk, &bku]<typename... As>(framework::pack<As...>) mutable {
-      auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
+      std::string key;
+      if constexpr (soa::is_iterator<std::decay_t<G>>) {
+        key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
+      }
       ([&bk, &bku, &key]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           auto binding = soa::getLabelFromTypeForKey<std::decay_t<As>>(key);
-          if constexpr (o2::soa::is_smallgroups_v<std::decay_t<As>>) {
+          if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
             framework::updatePairList(bku, binding, key);
           } else {
             framework::updatePairList(bk, binding, key);
@@ -121,18 +127,17 @@ struct AnalysisDataProcessorBuilder {
     }(framework::pack<Args...>{});
   }
 
-  template <typename O>
-  static void addOriginal(const char* name, bool value, std::vector<InputSpec>& inputs)
-    requires soa::has_metadata<aod::MetadataTrait<std::decay_t<O>>>
+  template <soa::TableRef R>
+  static void addOriginalRef(const char* name, bool value, std::vector<InputSpec>& inputs)
   {
-    using metadata = typename aod::MetadataTrait<std::decay_t<O>>::metadata;
+    using metadata = typename aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata;
     std::vector<ConfigParamSpec> inputMetadata;
     inputMetadata.emplace_back(ConfigParamSpec{std::string{"control:"} + name, VariantType::Bool, value, {"\"\""}});
-    if constexpr (soa::has_sources<typename aod::MetadataTrait<std::decay_t<O>>::metadata>) {
-      auto inputSources = getInputMetadata<std::decay_t<O>>();
+    if constexpr (soa::with_sources<metadata>) {
+      auto inputSources = getInputMetadata<metadata>();
       inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
     }
-    DataSpecUtils::updateInputList(inputs, InputSpec{metadata::tableLabel(), metadata::origin(), metadata::description(), metadata::version(), Lifetime::Timeframe, inputMetadata});
+    DataSpecUtils::updateInputList(inputs, InputSpec{o2::aod::label<R>(), o2::aod::origin<R>(), aod::description(o2::aod::signature<R>()), R.version, Lifetime::Timeframe, inputMetadata});
   }
 
   template <typename R, typename C, typename... Args>
@@ -163,50 +168,54 @@ struct AnalysisDataProcessorBuilder {
           eInfos.emplace_back(ai, hash, T::parent_t::hashes(), std::make_shared<arrow::Schema>(fields));
         }
         // add inputs from the originals
-        [&name, &value, &inputs]<typename... Os>(framework::pack<Os...>) mutable {
-          (addOriginal<Os>(name, value, inputs), ...);
-        }(soa::make_originals_from_type<T>());
+        auto adder = [&name, &value, &inputs]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) mutable {
+          (addOriginalRef<refs[Is]>(name, value, inputs), ...);
+        };
+        if constexpr (soa::is_table<T> || soa::is_filtered_table<T>) {
+          adder.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>());
+        } else if constexpr (soa::is_iterator<T> || soa::is_filtered_iterator<T>) {
+          adder.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>());
+        }
       }
       return true;
     }() &&
      ...);
   }
 
-  template <typename T>
+  template <soa::TableRef R>
   static auto extractTableFromRecord(InputRecord& record)
-    requires soa::has_metadata<aod::MetadataTrait<T>>
   {
-    auto table = record.get<TableConsumer>(aod::MetadataTrait<T>::metadata::tableLabel())->asArrowTable();
+    auto table = record.get<TableConsumer>(o2::aod::label<R>())->asArrowTable();
     if (table->num_rows() == 0) {
-      table = makeEmptyTable<T>(aod::MetadataTrait<T>::metadata::tableLabel());
+      table = makeEmptyTable<R>();
     }
     return table;
   }
 
-  template <typename T>
-  static auto extractTableFromRecord(InputRecord& record) requires soa::is_type_with_originals_v<T>
-  {
-    return extractFromRecord<T>(record, typename T::originals{});
-  }
-
-  template <soa::is_table T, typename... Os>
-  static auto extractFromRecord(InputRecord& record, pack<Os...>)
+  template <soa::is_table T>
+  static auto extractFromRecord(InputRecord& record)
   {
-    return T{{extractTableFromRecord<Os>(record)...}};
+    return T { [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>()) };
   }
 
-  template <soa::is_iterator T, typename... Os>
-  static auto extractFromRecord(InputRecord& record, pack<Os...>)
+  template <soa::is_iterator T>
+  static auto extractFromRecord(InputRecord& record)
   {
-    return typename T::parent_t{{extractTableFromRecord<Os>(record)...}};
+    return typename T::parent_t { [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()) };
   }
 
-  template <soa::is_filtered T, typename... Os>
-  static auto extractFilteredFromRecord(InputRecord& record, ExpressionInfo& info, pack<Os...> const&)
+  template <soa::is_filtered T>
+  static auto extractFilteredFromRecord(InputRecord& record, ExpressionInfo& info)
   {
-    auto table = o2::soa::ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>{extractTableFromRecord<Os>(record)...});
+    std::shared_ptr<arrow::Table> table = nullptr;
+    auto joiner = [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; };
+    if constexpr (soa::is_iterator<T>) {
+      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()));
+    } else {
+      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>()));
+    }
     expressions::updateFilterInfo(info, table);
-    if constexpr (!o2::soa::is_smallgroups_v<std::decay_t<T>>) {
+    if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
       if (info.selection == nullptr) {
         soa::missingFilterDeclaration(info.processHash, info.argumentIndex);
       }
@@ -227,10 +236,10 @@ struct AnalysisDataProcessorBuilder {
   template <soa::is_iterator T, int AI>
   static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash)
   {
-    if constexpr (std::is_same_v<typename T::policy_t, soa::FilteredIndexPolicy>) {
-      return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }), soa::make_originals_from_type<T>());
+    if constexpr (std::same_as<typename T::policy_t, soa::FilteredIndexPolicy>) {
+      return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }));
     } else {
-      return extractFromRecord<T>(record, soa::make_originals_from_type<T>());
+      return extractFromRecord<T>(record);
     }
   }
 
@@ -238,15 +247,15 @@ struct AnalysisDataProcessorBuilder {
   static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash)
   {
     if constexpr (soa::is_filtered_table<T>) {
-      return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }), soa::make_originals_from_type<T>());
+      return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }));
     } else {
-      return extractFromRecord<T>(record, soa::make_originals_from_type<T>());
+      return extractFromRecord<T>(record);
     }
   }
 
   template <typename R, typename C, typename Grouping, typename... Args>
   static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
-    requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
+    requires(!std::same_as<Grouping, void>)
   {
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
     return extract<std::decay_t<Grouping>, 0>(record, infos, hash);
@@ -254,7 +263,7 @@ struct AnalysisDataProcessorBuilder {
 
   template <typename R, typename C, typename Grouping, typename... Args>
   static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
-    requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
+    requires(!std::same_as<Grouping, void> && sizeof...(Args) > 0)
   {
     constexpr auto p = pack<Args...>{};
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
@@ -495,7 +504,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   homogeneous_apply_refs(
     [name = name_str, &expressionInfos, &inputs, &bindingsKeys, &bindingsKeysUnsorted](auto& x) {
       using D = std::decay_t<decltype(x)>;
-      if constexpr (is_base_of_template_v<ProcessConfigurable, D>) {
+      if constexpr (base_of_template<ProcessConfigurable, D>) {
         // this pushes (argumentIndex,processHash,schemaPtr,nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
         AnalysisDataProcessorBuilder::inputsFromArgs(x.process, (name + "/" + x.name).c_str(), x.value, inputs, expressionInfos, bindingsKeys, bindingsKeysUnsorted);
         return true;
@@ -607,7 +616,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       // execute optional process()
       homogeneous_apply_refs(
         [&pc, &expressionInfos, &task, &slices](auto& x) mutable {
-          if constexpr (is_base_of_template_v<ProcessConfigurable, std::decay_t<decltype(x)>>) {
+          if constexpr (base_of_template<ProcessConfigurable, std::decay_t<decltype(x)>>) {
             if (x.value == true) {
               AnalysisDataProcessorBuilder::invokeProcess(*task.get(), pc.inputs(), x.process, expressionInfos, slices);
               return true;
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index ffd2d0c0360d0..ea04aa3b5a5b3 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -15,8 +15,6 @@
 #include "Framework/ASoA.h"
 #include "Framework/HistogramSpec.h" // only for VARIABLE_WIDTH
 #include "Framework/Pack.h"
-#include "Framework/ArrowTypes.h"
-#include <optional>
 
 namespace o2::framework
 {
@@ -269,7 +267,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
     return BinningPolicyBase<sizeof...(Ts)>::template getBin<T2s...>(data);
   }
 
-  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_t, Ts...>;
+  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_column_t, Ts...>;
 
  private:
   std::tuple<Ls...> mBinningFunctions;
@@ -298,7 +296,7 @@ struct ColumnBinningPolicy : BinningPolicyBase<sizeof...(Ts)> {
     return BinningPolicyBase<sizeof...(Ts)>::template getBin<typename Ts::type...>(data);
   }
 
-  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_t, Ts...>;
+  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_column_t, Ts...>;
 };
 
 template <typename C>
@@ -323,7 +321,7 @@ struct NoBinningPolicy {
     return std::get<0>(data);
   }
 
-  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_t, C>;
+  using persistent_columns_t = framework::selected_pack<o2::soa::is_persistent_column_t, C>;
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 877474fb9ede6..b9775f031c65c 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -81,34 +81,29 @@ using LiteralValue = LiteralStorage<int, bool, float, double, uint8_t, int64_t,
 template <typename T>
 constexpr auto selectArrowType()
 {
-  if constexpr (std::is_same_v<T, int>) {
-    return atype::INT32;
-  } else if constexpr (std::is_same_v<T, bool>) {
-    return atype::BOOL;
-  } else if constexpr (std::is_same_v<T, float>) {
-    return atype::FLOAT;
-  } else if constexpr (std::is_same_v<T, double>) {
-    return atype::DOUBLE;
-  } else if constexpr (std::is_same_v<T, uint8_t>) {
-    return atype::UINT8;
-  } else if constexpr (std::is_same_v<T, int8_t>) {
-    return atype::INT8;
-  } else if constexpr (std::is_same_v<T, uint16_t>) {
-    return atype::UINT16;
-  } else if constexpr (std::is_same_v<T, int16_t>) {
-    return atype::INT16;
-  } else if constexpr (std::is_same_v<T, int64_t>) {
-    return atype::INT64;
-  } else if constexpr (std::is_same_v<T, uint32_t>) {
-    return atype::UINT32;
-  } else if constexpr (std::is_same_v<T, uint64_t>) {
-    return atype::UINT64;
-  } else {
-    return atype::NA;
-  }
-  O2_BUILTIN_UNREACHABLE();
+  return atype::NA;
 }
 
+#define SELECT_ARROW_TYPE(_Ctype_, _Atype_) \
+  template <typename T>                     \
+    requires std::same_as<T, _Ctype_>       \
+  constexpr auto selectArrowType()          \
+  {                                         \
+    return atype::_Atype_;                  \
+  }
+
+SELECT_ARROW_TYPE(bool, BOOL);
+SELECT_ARROW_TYPE(float, FLOAT);
+SELECT_ARROW_TYPE(double, DOUBLE);
+SELECT_ARROW_TYPE(uint8_t, UINT8);
+SELECT_ARROW_TYPE(int8_t, INT8);
+SELECT_ARROW_TYPE(uint16_t, UINT16);
+SELECT_ARROW_TYPE(int16_t, INT16);
+SELECT_ARROW_TYPE(uint32_t, UINT32);
+SELECT_ARROW_TYPE(int32_t, INT32);
+SELECT_ARROW_TYPE(uint64_t, UINT64);
+SELECT_ARROW_TYPE(int64_t, INT64);
+
 std::shared_ptr<arrow::DataType> concreteArrowType(atype::type type);
 std::string upcastTo(atype::type f);
 
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index a53f70d46015b..8fd96fb00156c 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -52,7 +52,7 @@ struct GroupSlicer {
       if constexpr (o2::soa::relatedByIndex<std::decay_t<G>, std::decay_t<T>>()) {
         auto binding = o2::soa::getLabelFromTypeForKey<std::decay_t<T>>(mIndexColumnName);
         auto bk = std::make_pair(binding, mIndexColumnName);
-        if constexpr (!o2::soa::is_smallgroups_v<std::decay_t<T>>) {
+        if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
           if (table.size() == 0) {
             return;
           }
@@ -165,7 +165,7 @@ struct GroupSlicer {
           pos = position;
         }
 
-        if constexpr (!o2::soa::is_smallgroups_v<std::decay_t<A1>>) {
+        if constexpr (!o2::soa::is_smallgroups<std::decay_t<A1>>) {
           // optimized split
           if (originalTable.size() == 0) {
             return originalTable;
@@ -225,7 +225,7 @@ struct GroupSlicer {
           }
         }
       } else {
-        static_assert(!o2::soa::is_smallgroups_v<std::decay_t<A1>>, "SmallGroups used with a table that is not related by index to the gouping table");
+        static_assert(!o2::soa::is_smallgroups<std::decay_t<A1>>, "SmallGroups used with a table that is not related by index to the gouping table");
         return originalTable;
       }
     }
diff --git a/Framework/Core/include/Framework/IndexBuilderHelpers.h b/Framework/Core/include/Framework/IndexBuilderHelpers.h
index 52cbd7b921dfe..f476bd7da7e55 100644
--- a/Framework/Core/include/Framework/IndexBuilderHelpers.h
+++ b/Framework/Core/include/Framework/IndexBuilderHelpers.h
@@ -83,9 +83,9 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   template <typename C>
   inline std::shared_ptr<arrow::ChunkedArray> result() const
   {
-    if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
+    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
       return resultMulti();
-    } else if constexpr (std::is_same_v<typename C::type, int[2]>) {
+    } else if constexpr (std::same_as<typename C::type, int[2]>) {
       return resultSlice();
     } else {
       return resultSingle();
@@ -95,9 +95,9 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   template <typename C>
   inline bool find(int idx)
   {
-    if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
+    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
       return findMulti(idx);
-    } else if constexpr (std::is_same_v<typename C::type, int[2]>) {
+    } else if constexpr (std::same_as<typename C::type, int[2]>) {
       return findSlice(idx);
     } else {
       return findSingle(idx);
@@ -108,9 +108,9 @@ class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIte
   inline void fill(int idx)
   {
     ++mResultSize;
-    if constexpr (std::is_same_v<typename C::type, std::vector<int>>) {
+    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
       fillMulti(idx);
-    } else if constexpr (std::is_same_v<typename C::type, int[2]>) {
+    } else if constexpr (std::same_as<typename C::type, int[2]>) {
       fillSlice(idx);
     } else {
       fillSingle(idx);
diff --git a/Framework/Core/include/Framework/StringHelpers.h b/Framework/Core/include/Framework/StringHelpers.h
index 2bc5e7b4a30d5..3da10fb0f561d 100644
--- a/Framework/Core/include/Framework/StringHelpers.h
+++ b/Framework/Core/include/Framework/StringHelpers.h
@@ -77,6 +77,11 @@ consteval uint32_t compile_time_hash(char const* str)
   return crc32(str, static_cast<int>(__builtin_strlen(str)) - 1) ^ 0xFFFFFFFF;
 }
 
+consteval uint32_t operator""_h(const char* str, size_t)
+{
+  return compile_time_hash(str);
+}
+
 constexpr uint32_t runtime_crc32(char const* str, int length)
 {
   uint32_t crc = 0xFFFFFFFF;
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 1c7b96b35f122..b9c5a8ed732b6 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -52,12 +52,7 @@ namespace o2::framework
 {
 namespace detail
 {
-/// FIXME: adapt type conversion to arrow 1.0
-// This is needed by Arrow 0.12.0 which dropped
-//
-//      using ArrowType = ArrowType_;
-//
-// from ARROW_STL_CONVERSION
+/// FIXME: adapt type conversion to new arrow
 template <typename T>
 struct ConversionTraits {
 };
@@ -72,6 +67,11 @@ struct ConversionTraits<T[N]> {
   using ArrowType = ::arrow::FixedSizeListType;
 };
 
+template <typename T, int N>
+struct ConversionTraits<std::array<T, N>> {
+  using ArrowType = ::arrow::FixedSizeListType;
+};
+
 template <typename T>
 struct ConversionTraits<std::vector<T>> {
   using ArrowType = ::arrow::ListType;
@@ -366,6 +366,27 @@ struct BuilderMaker<T[N]> {
   }
 };
 
+template <typename T, int N>
+struct BuilderMaker<std::array<T, N>> {
+  using FillType = T*;
+  using BuilderType = arrow::FixedSizeListBuilder;
+  using ArrowType = arrow::FixedSizeListType;
+  using ElementType = typename detail::ConversionTraits<T>::ArrowType;
+
+  static std::unique_ptr<BuilderType> make(arrow::MemoryPool* pool)
+  {
+    std::unique_ptr<arrow::ArrayBuilder> valueBuilder;
+    auto status =
+      arrow::MakeBuilder(pool, arrow::TypeTraits<ElementType>::type_singleton(), &valueBuilder);
+    return std::make_unique<BuilderType>(pool, std::move(valueBuilder), N);
+  }
+
+  static std::shared_ptr<arrow::DataType> make_datatype()
+  {
+    return arrow::fixed_size_list(arrow::TypeTraits<ElementType>::type_singleton(), N);
+  }
+};
+
 template <typename T>
 struct BuilderMaker<std::vector<T>> {
   using FillType = std::vector<T>;
@@ -757,6 +778,12 @@ class TableBuilder
     }(typename T::table_t::persistent_columns_t{});
   }
 
+  template <typename... Cs>
+  auto cursor(framework::pack<Cs...>)
+  {
+    return this->template persist<typename Cs::type...>({Cs::columnLabel()...});
+  }
+
   template <typename T, typename E>
   auto cursor()
   {
@@ -839,16 +866,84 @@ auto makeEmptyTable(const char* name)
   return b.finalize();
 }
 
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table>& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
+template <soa::TableRef R>
+auto makeEmptyTable()
+{
+  TableBuilder b;
+  [[maybe_unused]] auto writer = b.cursor(typename aod::MetadataTrait<aod::Hash<R.desc_hash>>::metadata::persistent_columns_t{});
+  b.setLabel(aod::label<R>());
+  return b.finalize();
+}
+
+template <typename... Cs>
+auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
+{
+  TableBuilder b;
+  [[maybe_unused]] auto writer = b.cursor(p);
+  b.setLabel(name);
+  return b.finalize();
+}
+
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
                                             expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name);
 
 /// Expression-based column generator to materialize columns
-template <o2::framework::OriginEnc ORIGIN, typename... C>
+template <aod::is_aod_hash D>
+auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
+{
+  using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable(name, expression_pack_t{});
+  }
+  static auto fields = o2::soa::createFieldsFromColumns(expression_pack_t{});
+  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
+  {
+    return {{std::move(C::Projector())...}};
+  }
+  (expression_pack_t{});
+
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
+}
+
+template <aod::is_aod_hash D>
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name)
+{
+  using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable(name, expression_pack_t{});
+  }
+  static auto fields = o2::soa::createFieldsFromColumns(expression_pack_t{});
+  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
+  {
+    return {{std::move(C::Projector())...}};
+  }
+  (expression_pack_t{});
+
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
+}
+
+// template <soa::OriginEnc ORIGIN, typename... C>
+// auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
+// {
+//   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+//   if (fullTable->num_rows() == 0) {
+//     return makeEmptyTable<soa::Table<ORIGIN, C...>>(name);
+//   }
+//   static auto fields = o2::soa::createFieldsFromColumns(columns);
+//   static auto new_schema = std::make_shared<arrow::Schema>(fields);
+//   std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
+//   return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), fields, name);
+// }
+
+template <typename... C>
 auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
 {
   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
   if (fullTable->num_rows() == 0) {
-    return makeEmptyTable<soa::Table<ORIGIN, C...>>(name);
+    return makeEmptyTable(name, framework::pack<C...>{});
   }
   static auto fields = o2::soa::createFieldsFromColumns(columns);
   static auto new_schema = std::make_shared<arrow::Schema>(fields);
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index bbfc8624b4e52..7f2b50186ac0f 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -65,18 +65,6 @@ static inline auto doExtractOriginal(framework::pack<Ts...>, ProcessingContext&
   }
 }
 
-template <typename O>
-static inline auto extractTypedOriginal(ProcessingContext& pc)
-{
-  return O{doExtractOriginal(soa::make_originals_from_type<O>(), pc)};
-}
-
-template <typename O>
-static inline auto extractOriginal(ProcessingContext& pc)
-{
-  return o2::soa::ArrowHelpers::joinTables({doExtractOriginal(soa::make_originals_from_type<O>(), pc)});
-}
-
 template <typename... Os>
 static inline auto extractOriginalsTuple(framework::pack<Os...>, ProcessingContext& pc)
 {
@@ -89,6 +77,14 @@ static inline auto extractOriginalsVector(framework::pack<Os...>, ProcessingCont
   return std::vector{extractOriginal<Os>(pc)...};
 }
 
+template <size_t N, std::array<soa::TableRef, N> refs>
+static inline auto extractOriginals(ProcessingContext& pc)
+{
+  return [&]<size_t... Is>(std::index_sequence<Is...>) -> std::vector<std::shared_ptr<arrow::Table>> {
+    return {pc.inputs().get<TableConsumer>(o2::aod::label<refs[Is]>())->asArrowTable()...};
+  }(std::make_index_sequence<refs.size()>());
+}
+
 AlgorithmSpec AODReaderHelpers::indexBuilderCallback(std::vector<InputSpec>& requested)
 {
   return AlgorithmSpec::InitCallback{[requested](InitContext& ic) {
@@ -101,17 +97,15 @@ AlgorithmSpec AODReaderHelpers::indexBuilderCallback(std::vector<InputSpec>& req
           using metadata_t = decltype(metadata);
           using Key = typename metadata_t::Key;
           using index_pack_t = typename metadata_t::index_pack_t;
-          using originals = typename metadata_t::originals;
+          constexpr auto sources = metadata_t::sources;
           if constexpr (metadata_t::exclusive == true) {
-            return o2::framework::IndexBuilder<o2::framework::Exclusive>::indexBuilder<Key>(input.binding.c_str(),
-                                                                                            extractOriginalsVector(originals{}, pc),
-                                                                                            index_pack_t{},
-                                                                                            originals{});
+            return o2::framework::IndexBuilder<o2::framework::Exclusive>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
+                                                                                                                     extractOriginals<sources.size(), sources>(pc),
+                                                                                                                     index_pack_t{});
           } else {
-            return o2::framework::IndexBuilder<o2::framework::Sparse>::indexBuilder<Key>(input.binding.c_str(),
-                                                                                         extractOriginalsVector(originals{}, pc),
-                                                                                         index_pack_t{},
-                                                                                         originals{});
+            return o2::framework::IndexBuilder<o2::framework::Sparse>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
+                                                                                                                  extractOriginals<sources.size(), sources>(pc),
+                                                                                                                  index_pack_t{});
           }
         };
 
@@ -153,49 +147,41 @@ AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(std::vector<InputSpec>& reque
       // spawn tables
       for (auto& input : requested) {
         auto&& [origin, description, version] = DataSpecUtils::asConcreteDataMatcher(input);
-
-        auto maker = [&](auto metadata) {
-          using metadata_t = decltype(metadata);
-          using expressions = typename metadata_t::expression_pack_t;
-          std::vector<std::shared_ptr<arrow::Table>> originalTables;
-          for (auto& i : input.metadata) {
-            if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
-              auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
-              originalTables.push_back(pc.inputs().get<TableConsumer>(spec.binding)->asArrowTable());
-            }
-          }
-          return o2::framework::spawner<metadata_t::origin()>(expressions{}, std::move(originalTables), input.binding.c_str());
+        auto maker = [&]<o2::aod::is_aod_hash D>() {
+          using metadata_t = o2::aod::MetadataTrait<D>::metadata;
+          constexpr auto sources = metadata_t::sources;
+          return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str());
         };
 
-        if (description == header::DataDescription{"TRACK"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksExtensionMetadata{}));
-        } else if (description == header::DataDescription{"TRACK_IU"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksIUExtensionMetadata{}));
-        } else if (description == header::DataDescription{"TRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksCovExtensionMetadata{}));
-        } else if (description == header::DataDescription{"TRACKCOV_IU"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksCovIUExtensionMetadata{}));
-        } else if (description == header::DataDescription{"TRACKEXTRA"}) {
+        if (description == header::DataDescription{"EXTRACK"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACK/0"_h>>());
+        } else if (description == header::DataDescription{"EXTRACK_IU"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACK_IU/0"_h>>());
+        } else if (description == header::DataDescription{"EXTRACKCOV"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKCOV/0"_h>>());
+        } else if (description == header::DataDescription{"EXTRACKCOV_IU"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKCOV_IU/0"_h>>());
+        } else if (description == header::DataDescription{"EXTRACKEXTRA"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksExtra_000ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKEXTRA/0"_h>>());
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::TracksExtra_001ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKEXTRA/1"_h>>());
           }
-        } else if (description == header::DataDescription{"MFTTRACK"}) {
+        } else if (description == header::DataDescription{"EXMFTTRACK"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::MFTTracks_000ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMFTTRACK/0"_h>>());
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::MFTTracks_001ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMFTTRACK/1"_h>>());
           }
-        } else if (description == header::DataDescription{"FWDTRACK"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::FwdTracksExtensionMetadata{}));
-        } else if (description == header::DataDescription{"FWDTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::FwdTracksCovExtensionMetadata{}));
-        } else if (description == header::DataDescription{"MCPARTICLE"}) {
+        } else if (description == header::DataDescription{"EXFWDTRACK"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXFWDTRACK/0"_h>>());
+        } else if (description == header::DataDescription{"EXFWDTRACKCOV"}) {
+          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXFWDTRACKCOV/0"_h>>());
+        } else if (description == header::DataDescription{"EXMCPARTICLE"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::McParticles_000ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMCPARTICLE/0"_h>>());
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker(o2::aod::McParticles_001ExtensionMetadata{}));
+            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMCPARTICLE/1"_h>>());
           }
         } else {
           throw runtime_error("Not an extended table");
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index e652e1b7aab2d..bb4cfbbe28dc0 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -115,11 +115,14 @@ std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared
 
 arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, const char* label)
 {
-  auto index = table->schema()->GetAllFieldIndices(label);
-  if (index.empty()) {
+  auto field = std::find_if(table->schema()->fields().begin(), table->schema()->fields().end(), [&](std::shared_ptr<arrow::Field> const& f) {
+    return o2::framework::strToUpper(label) == o2::framework::strToUpper(std::string{f->name()});
+  });
+  if (field == table->schema()->fields().end()) {
     o2::framework::throw_error(o2::framework::runtime_error_f("Unable to find column with label %s", label));
   }
-  return table->column(index[0]).get();
+  auto index = std::distance(table->schema()->fields().begin(), field);
+  return table->column(index).get();
 }
 
 void notBoundTable(const char* tableName)
@@ -149,4 +152,10 @@ std::string cutString(std::string&& str)
   }
   return str;
 }
+
+std::string strToUpper(std::string&& str)
+{
+  std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return std::toupper(c); });
+  return str;
+}
 } // namespace o2::framework
diff --git a/Framework/Core/src/AnalysisDataModel.cxx b/Framework/Core/src/AnalysisDataModel.cxx
index fbbabc35f0aab..906772234d608 100644
--- a/Framework/Core/src/AnalysisDataModel.cxx
+++ b/Framework/Core/src/AnalysisDataModel.cxx
@@ -12,12 +12,12 @@
 
 namespace o2::soa
 {
-template struct Join<aod::BCs, aod::Timestamps>;
-template struct Join<aod::Tracks, aod::TracksExtra>;
-template struct Join<aod::Tracks, aod::TracksCov, aod::TracksExtra>;
-template struct Join<aod::FwdTracks, aod::FwdTracksCov>;
-template struct Join<aod::Collisions, aod::Run2MatchedSparse>;
-template struct Join<aod::Collisions, aod::Run3MatchedSparse>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::BCs, aod::Timestamps>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksExtra>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksCov, aod::TracksExtra>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::FwdTracks, aod::FwdTracksCov>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run2MatchedSparse>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run3MatchedSparse>;
 
-template struct Join<aod::TracksExtension, aod::StoredTracks>;
+template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::TracksExtension, aod::StoredTracks>;
 } // namespace o2::soa
diff --git a/Framework/Core/src/IndexBuilderHelpers.cxx b/Framework/Core/src/IndexBuilderHelpers.cxx
index 4939d0ffb8da7..2d3a058ccb1c7 100644
--- a/Framework/Core/src/IndexBuilderHelpers.cxx
+++ b/Framework/Core/src/IndexBuilderHelpers.cxx
@@ -43,8 +43,8 @@ std::shared_ptr<arrow::Field> SelfIndexColumnBuilder::field() const
 }
 
 IndexColumnBuilder::IndexColumnBuilder(std::shared_ptr<arrow::ChunkedArray> source, const char* name, int listSize, arrow::MemoryPool* pool)
-  : ChunkedArrayIterator{source},
-    SelfIndexColumnBuilder{name, pool},
+  : SelfIndexColumnBuilder{name, pool},
+    ChunkedArrayIterator{source},
     mListSize{listSize},
     mSourceSize{(size_t)source->length()}
 {
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index d7a07374ee745..5681568d40ebd 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -84,7 +84,7 @@ void TableBuilder::setLabel(const char* label)
   mSchema = mSchema->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{label}}));
 }
 
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table>& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
                                             expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name)
 {
   auto mergedProjectors = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), fields);
diff --git a/Framework/Core/src/verifyAODFile.cxx b/Framework/Core/src/verifyAODFile.cxx
index 470d680a11191..2660019031946 100644
--- a/Framework/Core/src/verifyAODFile.cxx
+++ b/Framework/Core/src/verifyAODFile.cxx
@@ -23,7 +23,7 @@ using namespace o2::soa;
 template <typename T>
 void verifyTable(TFile* infile, const char* branchName)
 {
-  std::cout << "Table: " << o2::aod::MetadataTrait<T>::metadata::tableLabel() << std::endl;
+  std::cout << "Table: " << o2::aod::label<T::ref>() << std::endl;
   std::unique_ptr<TTreeReader> reader = std::make_unique<TTreeReader>(branchName, infile);
   TableBuilder builder;
   RootTableBuilderHelpers::convertASoA<T>(builder, *reader);
diff --git a/Framework/Core/test/benchmark_ASoA.cxx b/Framework/Core/test/benchmark_ASoA.cxx
index 4a845fb0d3d38..8dfac9e735c0b 100644
--- a/Framework/Core/test/benchmark_ASoA.cxx
+++ b/Framework/Core/test/benchmark_ASoA.cxx
@@ -19,9 +19,10 @@
 using namespace o2::framework;
 using namespace arrow;
 using namespace o2::soa;
+using namespace o2::aod;
 
-DECLARE_SOA_METADATA();
-DECLARE_SOA_VERSIONING();
+namespace o2::aod
+{
 namespace test
 {
 DECLARE_SOA_COLUMN_FULL(X, x, float, "x");
@@ -31,6 +32,7 @@ DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](float x, float y) { return x + y; });
 } // namespace test
 
 DECLARE_SOA_TABLE(TestTable, "AOD", "TESTTBL", test::X, test::Y, test::Z, test::Sum<test::X, test::Y>);
+} // namespace o2::aod
 
 #ifdef __APPLE__
 constexpr unsigned int maxrange = 10;
@@ -217,7 +219,7 @@ static void BM_ASoASimpleForLoop(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
 
   for (auto _ : state) {
     float sum = 0;
@@ -245,7 +247,7 @@ static void BM_ASoASimpleForLoopWithOp(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X, test::Y>;
 
   for (auto _ : state) {
     Test tests{table};
@@ -273,7 +275,7 @@ static void BM_ASoADynamicColumnPresent(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};
@@ -301,7 +303,7 @@ static void BM_ASoADynamicColumnCall(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>>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X, test::Y, test::Sum<test::X, test::Y>>;
 
   Test tests{table};
   for (auto _ : state) {
diff --git a/Framework/Core/test/benchmark_ASoAHelpers.cxx b/Framework/Core/test/benchmark_ASoAHelpers.cxx
index 6713f02c56fe0..e2c4dcaac7f66 100644
--- a/Framework/Core/test/benchmark_ASoAHelpers.cxx
+++ b/Framework/Core/test/benchmark_ASoAHelpers.cxx
@@ -97,7 +97,7 @@ static void BM_ASoAHelpersNaiveSimplePairs(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/1"_h, test::X>;
   Test tests{table};
   int64_t count = 0;
 
@@ -131,7 +131,7 @@ static void BM_ASoAHelpersNaiveSimpleFives(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/2"_h, test::X>;
   Test tests{table};
   int64_t count = 0;
 
@@ -323,7 +323,7 @@ static void BM_ASoAHelpersCombGenSimplePairs(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
 
   int64_t count = 0;
@@ -354,7 +354,7 @@ static void BM_ASoAHelpersCombGenSimpleFives(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
 
   int64_t count = 0;
@@ -520,8 +520,8 @@ static void BM_ASoAHelpersCombGenSimpleFivesMultipleChunks(benchmark::State& sta
   }
   auto tableB = builderB.finalize();
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X>;
+  using TestA = o2::soa::InPlaceTable<"A/0"_h, o2::soa::Index<>, test::X, test::Y>;
+  using TestB = o2::soa::InPlaceTable<"A/0"_h, o2::soa::Index<>, test::X>;
   using ConcatTest = Concat<TestA, TestB>;
 
   ConcatTest tests{tableA, tableB};
@@ -596,7 +596,7 @@ static void BM_ASoAHelpersCombGenSimplePairsSameCategories(benchmark::State& sta
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
   NoBinningPolicy<test::X> noBinning;
 
@@ -629,7 +629,7 @@ static void BM_ASoAHelpersCombGenSimpleFivesSameCategories(benchmark::State& sta
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
   NoBinningPolicy<test::X> noBinning;
 
@@ -662,7 +662,7 @@ static void BM_ASoAHelpersCombGenSimplePairsCategories(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
   NoBinningPolicy<test::X> noBinning;
 
@@ -695,7 +695,7 @@ static void BM_ASoAHelpersCombGenSimpleFivesCategories(benchmark::State& state)
   }
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X>;
+  using Test = o2::soa::InPlaceTable<"A/0"_h, test::X>;
   Test tests{table};
   NoBinningPolicy<test::X> noBinning;
 
diff --git a/Framework/Core/test/benchmark_TableBuilder.cxx b/Framework/Core/test/benchmark_TableBuilder.cxx
index 15da01a5f8956..59d1450e895bd 100644
--- a/Framework/Core/test/benchmark_TableBuilder.cxx
+++ b/Framework/Core/test/benchmark_TableBuilder.cxx
@@ -10,11 +10,11 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/TableBuilder.h"
-#include "Framework/TableConsumer.h"
 
 #include <benchmark/benchmark.h>
 
 using namespace o2::framework;
+using namespace o2::soa;
 
 static void BM_TableBuilderOverhead(benchmark::State& state)
 {
@@ -22,7 +22,7 @@ static void BM_TableBuilderOverhead(benchmark::State& state)
 
   for (auto _ : state) {
     TableBuilder builder;
-    auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
+    [[maybe_unused]] auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
     auto table = builder.finalize();
   }
 }
@@ -35,7 +35,7 @@ static void BM_TableBuilderScalar(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.persist<float>({"x"});
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f);
     }
     auto table = builder.finalize();
@@ -52,7 +52,7 @@ static void BM_TableBuilderScalarReserved(benchmark::State& state)
     TableBuilder builder;
     auto rowWriter = builder.persist<float>({"x"});
     builder.reserve(o2::framework::pack<float>{}, state.range(0));
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f);
     }
     auto table = builder.finalize();
@@ -68,7 +68,7 @@ static void BM_TableBuilderScalarPresized(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.preallocatedPersist<float>({"x"}, state.range(0));
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f);
     }
     auto table = builder.finalize();
@@ -86,7 +86,7 @@ static void BM_TableBuilderScalarBulk(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto bulkWriter = builder.bulkPersist<float>({"x"}, state.range(0));
-    for (size_t i = 0; i < state.range(0) / chunkSize; ++i) {
+    for (auto i = 0; i < state.range(0) / chunkSize; ++i) {
       bulkWriter(0, chunkSize, buffer.data());
     }
     auto table = builder.finalize();
@@ -101,7 +101,7 @@ static void BM_TableBuilderSimple(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f, 0.f, 0.f);
     }
     auto table = builder.finalize();
@@ -116,7 +116,7 @@ static void BM_TableBuilderSimple2(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.persist<float, float, float>({"x", "y", "z"});
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f, 0.f, 0.f);
     }
     auto table = builder.finalize();
@@ -132,7 +132,7 @@ DECLARE_SOA_COLUMN(Y, y, float);
 DECLARE_SOA_COLUMN(Z, z, float);
 } // namespace test
 
-using TestVectors = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test::X, test::Y, test::Z>;
+using TestVectors = o2::soa::InPlaceTable<"TST/0"_h, test::X, test::Y, test::Z>;
 
 static void BM_TableBuilderSoA(benchmark::State& state)
 {
@@ -140,7 +140,7 @@ static void BM_TableBuilderSoA(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.cursor<TestVectors>();
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0.f, 0.f, 0.f);
     }
     auto table = builder.finalize();
@@ -155,7 +155,7 @@ static void BM_TableBuilderComplex(benchmark::State& state)
   for (auto _ : state) {
     TableBuilder builder;
     auto rowWriter = builder.persist<int, float, std::string, bool>({"x", "y", "s", "b"});
-    for (size_t i = 0; i < state.range(0); ++i) {
+    for (auto i = 0; i < state.range(0); ++i) {
       rowWriter(0, 0, 0., "foo", true);
     }
     auto table = builder.finalize();
diff --git a/Framework/Core/test/test_ASoA.cxx b/Framework/Core/test/test_ASoA.cxx
index 6c8b629e3f8bb..6d9ee16fec84d 100644
--- a/Framework/Core/test/test_ASoA.cxx
+++ b/Framework/Core/test/test_ASoA.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <cstdio>
 #include "Framework/ASoA.h"
 #include "Framework/Expressions.h"
 #include "Framework/AnalysisHelpers.h"
@@ -37,9 +38,9 @@ DECLARE_SOA_EXPRESSION_COLUMN(ESum, esum, int, test::x + test::y);
 DECLARE_SOA_TABLE(Points, "TEST", "POINTS", test::X, test::Y);
 DECLARE_SOA_TABLE(Points3Ds, "TEST", "PTS3D", o2::soa::Index<>, test::X, test::Y, test::Z);
 
-DECLARE_SOA_TABLE(Points3DsMk1, "TEST", "PTS3D_1", o2::soa::Index<>, o2::soa::Marker<1>, test::X, test::Y, test::Z);
-DECLARE_SOA_TABLE(Points3DsMk2, "TEST", "PTS3D_2", o2::soa::Index<>, o2::soa::Marker<2>, test::X, test::Y, test::Z);
-DECLARE_SOA_TABLE(Points3DsMk3, "TEST", "PTS3D_3", o2::soa::Index<>, o2::soa::Marker<3>, test::X, test::Y, test::Z);
+DECLARE_SOA_TABLE_VERSIONED(Points3DMk1s, "TEST", "PTS3D", 1, o2::soa::Index<>, o2::soa::Marker<1>, test::X, test::Y, test::Z);
+DECLARE_SOA_TABLE_VERSIONED(Points3DMk2s, "TEST", "PTS3D", 2, o2::soa::Index<>, o2::soa::Marker<2>, test::X, test::Y, test::Z);
+DECLARE_SOA_TABLE_VERSIONED(Points3DMk3s, "TEST", "PTS3D", 3, o2::soa::Index<>, o2::soa::Marker<3>, test::X, test::Y, test::Z);
 
 namespace test
 {
@@ -59,7 +60,7 @@ DECLARE_SOA_COLUMN_FULL(Thickness, thickness, int, "thickness");
 } // namespace test
 
 DECLARE_SOA_TABLE(Segments, "TEST", "SEGMENTS", test::N, test::PointAId, test::PointBId, test::InfoId);
-DECLARE_SOA_TABLE(SegmentsExtras, "TEST", "SEGMENTSEX", test::Thickness);
+DECLARE_SOA_TABLE(SegmentsExtras, "TEST", "SEGMENTSPLUS", test::Thickness);
 
 namespace test
 {
@@ -80,9 +81,9 @@ TEST_CASE("TestMarkers")
   auto t1 = b1.finalize();
 
   auto pt = o2::aod::Points3Ds{t1};
-  auto pt1 = o2::aod::Points3DsMk1{t1};
-  auto pt2 = o2::aod::Points3DsMk2{t1};
-  auto pt3 = o2::aod::Points3DsMk3{t1};
+  auto pt1 = o2::aod::Points3DMk1s{t1};
+  auto pt2 = o2::aod::Points3DMk2s{t1};
+  auto pt3 = o2::aod::Points3DMk3s{t1};
   REQUIRE(pt1.begin().mark() == (size_t)1);
   REQUIRE(pt2.begin().mark() == (size_t)2);
   REQUIRE(pt3.begin().mark() == (size_t)3);
@@ -130,7 +131,7 @@ TEST_CASE("TestTableIteration")
   ++tests;
   REQUIRE(tests.x() == 0);
   REQUIRE(tests.y() == 1);
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::X, o2::aod::test::Y>;
+  using Test = InPlaceTable<"T/0"_h, o2::aod::test::X, o2::aod::test::Y>;
   Test tests2{table};
   size_t value = 0;
   auto b = tests2.begin();
@@ -180,18 +181,18 @@ TEST_CASE("TestDynamicColumns")
   rowWriter(0, 1, 7);
   auto table = builder.finalize();
 
-  using Test = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::X, o2::aod::test::Y, o2::aod::test::Sum<o2::aod::test::X, o2::aod::test::Y>>;
+  using Test1 = InPlaceTable<"A"_h, o2::aod::test::X, o2::aod::test::Y, o2::aod::test::Sum<o2::aod::test::X, o2::aod::test::Y>>;
 
-  Test tests{table};
-  for (auto& test : tests) {
-    REQUIRE(test.sum() == test.x() + test.y());
+  Test1 tests1{table};
+  for (auto& test : tests1) {
+    REQUIRE(test.sum() == (test.x() + test.y()));
   }
 
-  using Test2 = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::X, o2::aod::test::Y, o2::aod::test::Sum<o2::aod::test::Y, o2::aod::test::Y>>;
+  using Test2 = InPlaceTable<"B"_h, o2::aod::test::X, o2::aod::test::Y, o2::aod::test::Sum<o2::aod::test::Y, o2::aod::test::Y>>;
 
   Test2 tests2{table};
   for (auto& test : tests2) {
-    REQUIRE(test.sum() == test.y() + test.y());
+    CHECK(test.sum() == (test.y() + test.y()));
   }
 }
 
@@ -267,9 +268,9 @@ TEST_CASE("TestJoinedTables")
   rowWriterZ(0, 8);
   auto tableZ = builderZ.finalize();
 
-  using TestX = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::X>;
-  using TestY = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::Y>;
-  using TestZ = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::Z>;
+  using TestX = InPlaceTable<"A0"_h, o2::aod::test::X>;
+  using TestY = InPlaceTable<"A1"_h, o2::aod::test::Y>;
+  using TestZ = InPlaceTable<"A2"_h, o2::aod::test::Z>;
   using Test = Join<TestX, TestY>;
 
   REQUIRE(Test::contains<TestX>());
@@ -286,14 +287,13 @@ TEST_CASE("TestJoinedTables")
     REQUIRE(7 == test.x() + test.y());
   }
 
-  auto tests2 = join<o2::framework::OriginEnc{"JOIN"}>(TestX{tableX}, TestY{tableY});
-  static_assert(std::is_same_v<Test::table_t, decltype(tests2)>,
-                "Joined tables should have the same type, regardless how we construct them");
+  auto tests2 = join(TestX{tableX}, TestY{tableY});
+  static_assert(std::same_as<Test::self_t, decltype(tests2)>, "Joined tables should have the same type, regardless how we construct them");
   for (auto& test : tests2) {
     REQUIRE(7 == test.x() + test.y());
   }
 
-  auto tests3 = join<o2::framework::OriginEnc{"JOIN"}>(TestX{tableX}, TestY{tableY}, TestZ{tableZ});
+  auto tests3 = join(TestX{tableX}, TestY{tableY}, TestZ{tableZ});
 
   for (auto& test : tests3) {
     REQUIRE(15 == test.x() + test.y() + test.z());
@@ -356,25 +356,25 @@ TEST_CASE("TestConcatTables")
   rowWriterD(0, 23, 15);
   auto tableD = builderD.finalize();
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>;
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, o2::aod::test::X>;
-  using TestC = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::Z>;
-  using TestD = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::aod::test::X, o2::aod::test::Z>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>; // o2::aod::TestA;
+  using TestB = InPlaceTable<0, o2::soa::Index<>, o2::aod::test::X>;                   // o2::aod::TestB;
+  using TestC = InPlaceTable<0, o2::aod::test::Z>;                                     // o2::aod::TestC;
+  using TestD = InPlaceTable<0, o2::aod::test::X, o2::aod::test::Z>;                   // o2::aod::TestD;
   using ConcatTest = Concat<TestA, TestB>;
   using JoinedTest = Join<TestA, TestC>;
   using NestedJoinTest = Join<JoinedTest, TestD>;
   using NestedConcatTest = Concat<Join<TestA, TestB>, TestD>;
 
-  static_assert(std::is_same_v<NestedJoinTest::table_t, o2::soa::Table<o2::framework::OriginEnc{"JOIN"}, o2::soa::Index<>, o2::aod::test::Y, o2::aod::test::X, o2::aod::test::Z>>, "Bad nested join");
+  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::is_same_v<ConcatTest::table_t, o2::soa::Table<o2::framework::OriginEnc{"CONC"}, o2::soa::Index<>, o2::aod::test::X>>, "Bad intersection of columns");
+  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};
   REQUIRE(16 == tests.size());
   for (auto& test : tests) {
     REQUIRE(test.index() == test.x());
   }
 
-  static_assert(std::is_same_v<NestedConcatTest::table_t, o2::soa::Table<o2::framework::OriginEnc{"CONC"}, o2::aod::test::X>>, "Bad nested concat");
+  static_assert(std::same_as<NestedConcatTest::columns_t, o2::framework::pack<o2::aod::test::X>>, "Bad nested concat");
 
   // Hardcode a selection for the first 5 odd numbers
   using FilteredTest = Filtered<TestA>;
@@ -517,7 +517,7 @@ TEST_CASE("TestDereference")
 
   REQUIRE(segments.begin().pointAId() == 0);
   REQUIRE(segments.begin().pointBId() == 1);
-  static_assert(std::is_same_v<decltype(segments.begin().pointA()), o2::aod::Points::iterator>);
+  static_assert(std::same_as<decltype(segments.begin().pointA()), o2::aod::Points::iterator>);
   auto i = segments.begin();
   using namespace o2::framework;
   i.bindExternalIndices(&points, &infos);
@@ -539,7 +539,7 @@ TEST_CASE("TestDereference")
   REQUIRE(j.pointB().x() == 3);
   REQUIRE(j.pointB().y() == 4);
 
-  auto joined = join<o2::framework::OriginEnc{"JOIN"}>(segments, segmentsExtras);
+  auto joined = join(segments, segmentsExtras);
   joined.bindExternalIndices(&points, &infos);
   auto se = joined.begin();
   REQUIRE(se.n() == 10);
@@ -574,9 +574,8 @@ TEST_CASE("TestFilteredOperators")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>; // o2::soa::Table<OriginEnc{"AOD"}, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>;
   using FilteredTest = Filtered<TestA>;
-  using NestedFilteredTest = Filtered<Filtered<TestA>>;
   using namespace o2::framework;
 
   expressions::Filter f1 = o2::aod::test::x < 4;
@@ -596,8 +595,7 @@ TEST_CASE("TestFilteredOperators")
   FilteredTest filteredUnion = filtered1 + filtered2;
   REQUIRE(6 == filteredUnion.size());
 
-  std::vector<std::tuple<int32_t, int32_t>> expectedUnion{
-    {0, 8}, {1, 9}, {2, 10}, {3, 11}, {6, 14}, {7, 15}};
+  std::vector<std::tuple<int32_t, int32_t>> expectedUnion{{0, 8}, {1, 9}, {2, 10}, {3, 11}, {6, 14}, {7, 15}};
   auto i = 0;
   for (auto& f : filteredUnion) {
     REQUIRE(std::get<0>(expectedUnion[i]) == f.x());
@@ -650,7 +648,7 @@ TEST_CASE("TestNestedFiltering")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, o2::aod::test::X, o2::aod::test::Y>;
   using FilteredTest = Filtered<TestA>;
   using NestedFilteredTest = Filtered<Filtered<TestA>>;
   using TripleNestedFilteredTest = Filtered<Filtered<Filtered<TestA>>>;
@@ -694,11 +692,11 @@ TEST_CASE("TestNestedFiltering")
 TEST_CASE("TestEmptyTables")
 {
   TableBuilder bPoints;
-  auto pwriter = bPoints.cursor<o2::aod::Points>();
+  [[maybe_unused]] auto pwriter = bPoints.cursor<o2::aod::Points>();
   auto pempty = bPoints.finalize();
 
   TableBuilder bInfos;
-  auto iwriter = bInfos.cursor<o2::aod::Infos>();
+  [[maybe_unused]] auto iwriter = bInfos.cursor<o2::aod::Infos>();
   auto iempty = bInfos.finalize();
 
   o2::aod::Points p{pempty};
@@ -720,10 +718,12 @@ DECLARE_SOA_INDEX_COLUMN(Origint, origint);
 DECLARE_SOA_INDEX_COLUMN_FULL(AltOrigint, altOrigint, int, Origints, "_alt");
 DECLARE_SOA_ARRAY_INDEX_COLUMN(Origint, origints);
 } // namespace test
+
 DECLARE_SOA_TABLE(References, "TEST", "REFS", o2::soa::Index<>, test::OrigintId);
 DECLARE_SOA_TABLE(OtherReferences, "TEST", "OREFS", o2::soa::Index<>, test::AltOrigintId);
 DECLARE_SOA_TABLE(ManyReferences, "TEST", "MREFS", o2::soa::Index<>, test::OrigintIds);
 } // namespace o2::aod
+
 TEST_CASE("TestIndexToFiltered")
 {
   TableBuilder b;
@@ -819,7 +819,7 @@ TEST_CASE("TestAdvancedIndices")
   auto it = prt.begin();
   auto s1 = it.pointSlice();
   auto g1 = it.pointGroup();
-  auto bb = std::is_same_v<decltype(s1), o2::aod::Points3Ds>;
+  auto bb = std::same_as<decltype(s1), o2::aod::Points3Ds>;
   REQUIRE(bb);
   REQUIRE(s1.size() == 2);
   aa = {2, 3, 4};
@@ -901,12 +901,12 @@ TEST_CASE("TestAdvancedIndices")
   c2 = 0;
   for (auto& p : pst) {
     auto op = p.otherPoint_as<o2::aod::PointsSelfIndex>();
-    auto bbb = std::is_same_v<decltype(op), o2::aod::PointsSelfIndex::iterator>;
+    auto bbb = std::same_as<decltype(op), o2::aod::PointsSelfIndex::iterator>;
     REQUIRE(bbb);
     REQUIRE(op.globalIndex() == references[i]);
 
     auto ops = p.pointSeq_as<o2::aod::PointsSelfIndex>();
-    auto bbbs = std::is_same_v<decltype(ops), o2::aod::PointsSelfIndex>;
+    auto bbbs = std::same_as<decltype(ops), o2::aod::PointsSelfIndex>;
     REQUIRE(bbbs);
 
     if (i == withSlices[c1]) {
@@ -923,7 +923,7 @@ TEST_CASE("TestAdvancedIndices")
     }
 
     auto opss = p.pointSet_as<o2::aod::PointsSelfIndex>();
-    auto bbba = std::is_same_v<decltype(opss), std::vector<o2::aod::PointsSelfIndex::iterator>>;
+    auto bbba = std::same_as<decltype(opss), std::vector<o2::aod::PointsSelfIndex::iterator>>;
     REQUIRE(bbba);
 
     auto opss_ids = p.pointSetIds();
@@ -947,7 +947,7 @@ TEST_CASE("TestAdvancedIndices")
 namespace o2::aod
 {
 DECLARE_SOA_TABLE(PointsSelfRef, "TEST", "PTSSR", test::OtherPointId, test::PointSeqIdSlice, test::PointSetIds);
-}
+} // namespace o2::aod
 
 TEST_CASE("TestSelfIndexRecursion")
 {
@@ -987,15 +987,15 @@ TEST_CASE("TestSelfIndexRecursion")
   for (auto& p : pst) {
     auto ops = p.pointSeq_as<o2::aod::PointsSelfIndex>();
     for (auto& pp : ops) {
-      auto bpp = std::is_same_v<std::decay_t<decltype(pp)>, o2::aod::PointsSelfIndex::iterator>;
+      auto bpp = std::same_as<std::decay_t<decltype(pp)>, o2::aod::PointsSelfIndex::iterator>;
       REQUIRE(bpp);
       auto opps = pp.pointSeq_as<o2::aod::PointsSelfIndex>();
       for (auto& ppp : opps) {
-        auto bppp = std::is_same_v<std::decay_t<decltype(ppp)>, o2::aod::PointsSelfIndex::iterator>;
+        auto bppp = std::same_as<std::decay_t<decltype(ppp)>, o2::aod::PointsSelfIndex::iterator>;
         REQUIRE(bppp);
         auto oppps = ppp.pointSeq_as<o2::aod::PointsSelfIndex>();
         for (auto& pppp : oppps) {
-          auto bpppp = std::is_same_v<std::decay_t<decltype(pppp)>, o2::aod::PointsSelfIndex::iterator>;
+          auto bpppp = std::same_as<std::decay_t<decltype(pppp)>, o2::aod::PointsSelfIndex::iterator>;
           REQUIRE(bpppp);
           auto opppps = pppp.pointSeq_as<o2::aod::PointsSelfIndex>();
         }
@@ -1040,16 +1040,16 @@ TEST_CASE("TestSelfIndexRecursion")
   // FIXME: only 4 levels of recursive self-index dereference are tested
   // self-index binding should stay the same for recursive dereferences
   for (auto& p : fp) {
-    REQUIRE(std::is_same_v<std::decay_t<decltype(p)>, FullPoints::iterator>);
+    REQUIRE(std::same_as<std::decay_t<decltype(p)>, FullPoints::iterator>);
     auto ops = p.pointSeq_as<FullPoints>();
     for (auto& pp : ops) {
-      REQUIRE(std::is_same_v<std::decay_t<decltype(pp)>, FullPoints::iterator>);
+      REQUIRE(std::same_as<std::decay_t<decltype(pp)>, FullPoints::iterator>);
       auto opps = pp.pointSeq_as<FullPoints>();
       for (auto& ppp : opps) {
-        REQUIRE(std::is_same_v<std::decay_t<decltype(ppp)>, FullPoints::iterator>);
+        REQUIRE(std::same_as<std::decay_t<decltype(ppp)>, FullPoints::iterator>);
         auto oppps = ppp.pointSeq_as<FullPoints>();
         for (auto& pppp : oppps) {
-          REQUIRE(std::is_same_v<std::decay_t<decltype(pppp)>, FullPoints::iterator>);
+          REQUIRE(std::same_as<std::decay_t<decltype(pppp)>, FullPoints::iterator>);
           auto opppps = pppp.pointSeq_as<FullPoints>();
         }
       }
@@ -1062,9 +1062,9 @@ TEST_CASE("TestSelfIndexRecursion")
   for (auto& it1 : fpa) {
     [[maybe_unused]] auto it2 = fpa.rawIteratorAt(0);
     [[maybe_unused]] auto it3 = fpa.iteratorAt(0);
-    auto bit1 = std::is_same_v<std::decay_t<decltype(it1)>, std::decay_t<decltype(it2)>>;
+    auto bit1 = std::same_as<std::decay_t<decltype(it1)>, std::decay_t<decltype(it2)>>;
     REQUIRE(bit1);
-    auto bit2 = std::is_same_v<std::decay_t<decltype(it1)>, std::decay_t<decltype(it3)>>;
+    auto bit2 = std::same_as<std::decay_t<decltype(it1)>, std::decay_t<decltype(it3)>>;
     REQUIRE(bit2);
   }
 
@@ -1074,16 +1074,17 @@ TEST_CASE("TestSelfIndexRecursion")
 
   // Filter should not interfere with self-index and the binding should stay the same
   for (auto& p : ffp) {
-    REQUIRE(std::is_same_v<std::decay_t<decltype(p)>, FilteredPoints::iterator>);
+    REQUIRE(std::same_as<std::decay_t<decltype(p)>, FilteredPoints::iterator>);
+    REQUIRE(std::same_as<std::decay_t<decltype(p)>::parent_t, FilteredPoints>);
     auto ops = p.pointSeq_as<typename std::decay_t<decltype(p)>::parent_t>();
     for (auto& pp : ops) {
-      REQUIRE(std::is_same_v<std::decay_t<decltype(pp)>::parent_t, FilteredPoints>);
+      REQUIRE(std::same_as<std::decay_t<decltype(pp)>::parent_t, FilteredPoints>);
       auto opps = pp.pointSeq_as<FilteredPoints>();
       for (auto& ppp : opps) {
-        REQUIRE(std::is_same_v<std::decay_t<decltype(ppp)>, FilteredPoints::iterator>);
+        REQUIRE(std::same_as<std::decay_t<decltype(ppp)>, FilteredPoints::iterator>);
         auto oppps = ppp.pointSeq_as<FilteredPoints>();
         for (auto& pppp : oppps) {
-          REQUIRE(std::is_same_v<std::decay_t<decltype(pppp)>, FilteredPoints::iterator>);
+          REQUIRE(std::same_as<std::decay_t<decltype(pppp)>, FilteredPoints::iterator>);
           auto opppps = pppp.pointSeq_as<FilteredPoints>();
         }
       }
@@ -1099,15 +1100,15 @@ TEST_CASE("TestSelfIndexRecursion")
     using T1 = std::decay_t<decltype(it1)>;
     using T2 = std::decay_t<decltype(it2)>;
     using T3 = std::decay_t<decltype(it3)>;
-    auto bit1 = !std::is_same_v<T1, T2>;
+    auto bit1 = !std::same_as<T1, T2>;
     REQUIRE(bit1);
-    auto bit2 = !std::is_same_v<T1, T3>;
+    auto bit2 = !std::same_as<T1, T3>;
     REQUIRE(bit2);
-    auto bit3 = std::is_same_v<typename T1::policy_t, typename T3::policy_t>;
+    auto bit3 = std::same_as<typename T1::policy_t, typename T3::policy_t>;
     REQUIRE(bit3);
-    auto bit4 = std::is_same_v<typename T1::policy_t, o2::soa::FilteredIndexPolicy>;
+    auto bit4 = std::same_as<typename T1::policy_t, o2::soa::FilteredIndexPolicy>;
     REQUIRE(bit4);
-    auto bit5 = std::is_same_v<typename T2::policy_t, o2::soa::DefaultIndexPolicy>;
+    auto bit5 = std::same_as<typename T2::policy_t, o2::soa::DefaultIndexPolicy>;
     REQUIRE(bit5);
   }
 }
@@ -1134,8 +1135,8 @@ TEST_CASE("TestListColumns")
   for (auto& row : tbl) {
     auto f = row.l1();
     auto i = row.l2();
-    auto constexpr bf = std::is_same_v<decltype(f), gsl::span<const float, (size_t)-1>>;
-    auto constexpr bi = std::is_same_v<decltype(i), gsl::span<const int, (size_t)-1>>;
+    auto constexpr bf = std::same_as<decltype(f), gsl::span<const float, (size_t)-1>>;
+    auto constexpr bi = std::same_as<decltype(i), gsl::span<const int, (size_t)-1>>;
     REQUIRE(bf);
     REQUIRE(bi);
     REQUIRE(f.size() == s);
@@ -1300,7 +1301,7 @@ TEST_CASE("TestArrayColumns")
   for (auto const& row : li) {
     auto iir = row.smallIntArray();
     [[maybe_unused]] auto bbrr = row.boolArray_raw();
-    REQUIRE(std::is_same_v<std::decay_t<decltype(iir)>, int8_t const*>);
+    REQUIRE(std::same_as<std::decay_t<decltype(iir)>, int8_t const*>);
     for (auto i = 0; i < 32; ++i) {
       REQUIRE(iir[i] == i);
       REQUIRE(row.boolArray_bit(i) == (i % 2 == 0));
@@ -1318,10 +1319,12 @@ DECLARE_SOA_COLUMN(Three, three, double);
 DECLARE_SOA_COLUMN(Four, four, int[2]);
 DECLARE_SOA_DYNAMIC_COLUMN(Five, five, [](const int in[2]) -> float { return (float)in[0] / (float)in[1]; });
 } // namespace table
+
 DECLARE_SOA_TABLE(MixTest, "AOD", "MIXTST",
                   table::One, table::Two, table::Three, table::Four,
                   table::Five<table::Four>);
 } // namespace o2::aod
+
 TEST_CASE("TestCombinedGetter")
 {
   TableBuilder b;
@@ -1339,11 +1342,11 @@ TEST_CASE("TestCombinedGetter")
     auto features1 = row.getValues<float, o2::aod::table::One, o2::aod::table::Three>();
     auto features2 = row.getValues<double, o2::aod::table::One, o2::aod::table::Two, o2::aod::table::Three>();
     auto features3 = row.getValues<float, o2::aod::table::Two, o2::aod::table::Five<o2::aod::table::Four>>();
-    auto b1 = std::is_same_v<std::array<float, 2>, decltype(features1)>;
+    auto b1 = std::same_as<std::array<float, 2>, decltype(features1)>;
     REQUIRE(b1);
-    auto b2 = std::is_same_v<std::array<double, 3>, decltype(features2)>;
+    auto b2 = std::same_as<std::array<double, 3>, decltype(features2)>;
     REQUIRE(b2);
-    auto b3 = std::is_same_v<std::array<float, 2>, decltype(features3)>;
+    auto b3 = std::same_as<std::array<float, 2>, decltype(features3)>;
     REQUIRE(b3);
     REQUIRE(features1[0] == (float)count);
     REQUIRE(features1[1] == (float)(o2::constants::math::Almost0 * count));
diff --git a/Framework/Core/test/test_ASoAHelpers.cxx b/Framework/Core/test/test_ASoAHelpers.cxx
index a8ad8ff20c04d..c4d7f727aa295 100644
--- a/Framework/Core/test/test_ASoAHelpers.cxx
+++ b/Framework/Core/test/test_ASoAHelpers.cxx
@@ -42,7 +42,7 @@ TEST_CASE("IteratorTuple")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
 
   TestA tests{tableA};
 
@@ -113,8 +113,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
   auto tableB = builderB.finalize();
   REQUIRE(tableB->num_rows() == 4);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
+  using TestB = InPlaceTable<0, o2::soa::Index<>, test::X>;
   using ConcatTest = Concat<TestA, TestB>;
 
   TestA testsA{tableA};
@@ -141,8 +141,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
 
   auto comb2 = combinations(CombinationsStrictlyUpperIndexPolicy(testsA, testsA));
 
-  static_assert(std::is_same_v<decltype(comb2.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<TestA, TestA>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(comb2.begin())), CombinationsStrictlyUpperIndexPolicy<TestA, TestA>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(comb2.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<TestA, TestA>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(comb2.begin())), CombinationsStrictlyUpperIndexPolicy<TestA, TestA>::CombinationType&>, "Wrong combination type");
 
   auto beginCombination = *(comb2.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginCombination)).getIterator().mCurrentPos == nullptr));
@@ -176,8 +176,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
 
   auto comb2Filter = combinations(CombinationsStrictlyUpperIndexPolicy<TestA, TestA>(), filter, testsA, testsA);
 
-  static_assert(std::is_same_v<decltype(comb2Filter.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<Filtered<TestA>, Filtered<TestA>>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(comb2Filter.begin())), CombinationsStrictlyUpperIndexPolicy<Filtered<TestA>, Filtered<TestA>>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(comb2Filter.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<Filtered<TestA>, Filtered<TestA>>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(comb2Filter.begin())), CombinationsStrictlyUpperIndexPolicy<Filtered<TestA>, Filtered<TestA>>::CombinationType&>, "Wrong combination type");
 
   auto beginFilterCombination = *(comb2Filter.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginFilterCombination)).getIterator().mCurrentPos == nullptr));
@@ -199,8 +199,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
 
   auto comb2Concat = combinations(CombinationsStrictlyUpperIndexPolicy(concatTests, concatTests));
 
-  static_assert(std::is_same_v<decltype(comb2Concat.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<ConcatTest, ConcatTest>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(comb2Concat.begin())), CombinationsStrictlyUpperIndexPolicy<ConcatTest, ConcatTest>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(comb2Concat.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<ConcatTest, ConcatTest>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(comb2Concat.begin())), CombinationsStrictlyUpperIndexPolicy<ConcatTest, ConcatTest>::CombinationType&>, "Wrong combination type");
 
   auto beginConcatCombination = *(comb2Concat.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginConcatCombination)).getIterator().mCurrentPos == nullptr));
@@ -224,8 +224,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
 
   auto comb2Diff = combinations(CombinationsFullIndexPolicy(testsA, testsB));
 
-  static_assert(std::is_same_v<decltype(comb2Diff.begin()), CombinationsGenerator<CombinationsFullIndexPolicy<TestA, TestB>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(comb2Diff.begin())), CombinationsFullIndexPolicy<TestA, TestB>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(comb2Diff.begin()), CombinationsGenerator<CombinationsFullIndexPolicy<TestA, TestB>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(comb2Diff.begin())), CombinationsFullIndexPolicy<TestA, TestB>::CombinationType&>, "Wrong combination type");
 
   auto beginDiffCombination = *(comb2Diff.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginDiffCombination)).getIterator().mCurrentPos == nullptr));
@@ -248,8 +248,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
   // More elements required for a combination than number of elements in the table
   auto comb2Bad = combinations(CombinationsStrictlyUpperIndexPolicy(testsB, testsB, testsB, testsB, testsB));
 
-  static_assert(std::is_same_v<decltype(comb2Bad.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<TestB, TestB, TestB, TestB, TestB>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(comb2Bad.begin())), CombinationsStrictlyUpperIndexPolicy<TestB, TestB, TestB, TestB, TestB>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(comb2Bad.begin()), CombinationsGenerator<CombinationsStrictlyUpperIndexPolicy<TestB, TestB, TestB, TestB, TestB>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(comb2Bad.begin())), CombinationsStrictlyUpperIndexPolicy<TestB, TestB, TestB, TestB, TestB>::CombinationType&>, "Wrong combination type");
 
   auto beginBadCombination = *(comb2Bad.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginBadCombination)).getIterator().mCurrentPos == nullptr));
@@ -289,8 +289,8 @@ TEST_CASE("CombinationsGeneratorConstruction")
 
   auto combBlock = combinations(CombinationsBlockStrictlyUpperSameIndexPolicy(pairBinning, 2, -1, testsA, testsA));
 
-  static_assert(std::is_same_v<decltype(combBlock.begin()), CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<ColumnBinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>>::CombinationsIterator>, "Wrong iterator type");
-  static_assert(std::is_same_v<decltype(*(combBlock.begin())), CombinationsBlockStrictlyUpperSameIndexPolicy<ColumnBinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>::CombinationType&>, "Wrong combination type");
+  static_assert(std::same_as<decltype(combBlock.begin()), CombinationsGenerator<CombinationsBlockStrictlyUpperSameIndexPolicy<ColumnBinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>>::CombinationsIterator>, "Wrong iterator type");
+  static_assert(std::same_as<decltype(*(combBlock.begin())), CombinationsBlockStrictlyUpperSameIndexPolicy<ColumnBinningPolicy<test::Y, test::FloatZ>, int32_t, TestA, TestA>::CombinationType&>, "Wrong combination type");
 
   auto beginBlockCombination = *(combBlock.begin());
   REQUIRE(!(static_cast<test::X>(std::get<0>(beginBlockCombination)).getIterator().mCurrentPos == nullptr));
@@ -344,9 +344,9 @@ TEST_CASE("Combinations")
   auto tableC = builderC.finalize();
   REQUIRE(tableC->num_rows() == 4);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X>;
-  using TestC = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y, test::Z>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
+  using TestB = InPlaceTable<0, o2::soa::Index<>, test::X>;
+  using TestC = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y, test::Z>;
   using ConcatTest = Concat<TestA, TestB>;
 
   TestA testsA{tableA};
@@ -799,7 +799,7 @@ TEST_CASE("BreakingCombinations")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
 
   TestA testsA{tableA};
 
@@ -864,16 +864,16 @@ TEST_CASE("SmallTableCombinations")
   auto tableB = builderB.finalize();
   REQUIRE(tableB->num_rows() == 3);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
+  using TestB = InPlaceTable<0, o2::soa::Index<>, test::X>;
 
   TestA testsA{tableA};
   TestB testsB{tableB};
 
   REQUIRE(2 == testsA.size());
   REQUIRE(3 == testsB.size());
-  int nA = testsA.size();
-  int nB = testsB.size();
+  [[maybe_unused]] int nA = testsA.size();
+  [[maybe_unused]] int nB = testsB.size();
 
   int count = 0;
   int i = 0;
@@ -921,7 +921,7 @@ TEST_CASE("BlockCombinations")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 10);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
   TestA testA{tableA};
   REQUIRE(10 == testA.size());
 
@@ -950,7 +950,7 @@ TEST_CASE("BlockCombinations")
   // 2, 3, 5, 8, 9 have overflows in testA
   std::vector<std::tuple<int32_t, int32_t>> expectedFullPairsNoOverflows{
     {0, 0}, {0, 4}, {4, 0}, {4, 4}, {4, 7}, {7, 4}, {7, 7}, {1, 1}, {1, 6}, {6, 1}, {6, 6}};
-  int count = 0;
+  size_t count = 0;
   for (auto& [c0, c1] : combinations(CombinationsBlockFullIndexPolicy(pairBinningNoOverflows, 1, -1, testA, testA))) {
     REQUIRE(c0.x() == std::get<0>(expectedFullPairsNoOverflows[count]));
     REQUIRE(c1.x() == std::get<1>(expectedFullPairsNoOverflows[count]));
@@ -1204,14 +1204,14 @@ TEST_CASE("CombinationsHelpers")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
 
   TestA testsA{tableA};
 
   REQUIRE(8 == testsA.size());
   int nA = testsA.size();
 
-  int count = 0;
+  size_t count = 0;
   int i = 0;
   int j = 1;
   for (auto& [t0, t1] : pairCombinations(testsA)) {
@@ -1262,7 +1262,7 @@ TEST_CASE("CombinationsHelpers")
   auto tableB = builderB.finalize();
   REQUIRE(tableB->num_rows() == 10);
 
-  using TestB = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
+  using TestB = o2::soa::InPlaceTable<0, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
   TestB testB{tableB};
   REQUIRE(10 == testB.size());
 
@@ -1298,10 +1298,10 @@ TEST_CASE("CombinationsHelpers")
 
 TEST_CASE("ConstructorsWithoutTables")
 {
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y>;
   NoBinningPolicy<test::Y> noBinning;
 
-  int count = 0;
+  size_t count = 0;
   for (auto& [t0, t1] : pairCombinations<TestA>()) {
     count++;
   }
@@ -1343,7 +1343,7 @@ TEST_CASE("BlockCombinationsCounters")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 10);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
+  using TestA = InPlaceTable<0, o2::soa::Index<>, test::X, test::Y, test::FloatZ>;
   TestA testA{tableA};
   REQUIRE(10 == testA.size());
 
diff --git a/Framework/Core/test/test_AnalysisDataModel.cxx b/Framework/Core/test/test_AnalysisDataModel.cxx
index 0819e1a3ac822..b8b9c161f0e07 100644
--- a/Framework/Core/test/test_AnalysisDataModel.cxx
+++ b/Framework/Core/test/test_AnalysisDataModel.cxx
@@ -16,10 +16,11 @@
 
 using namespace o2::framework;
 using namespace arrow;
+using namespace o2::soa;
+using namespace o2::aod;
 
-DECLARE_SOA_METADATA();
-DECLARE_SOA_VERSIONING();
-
+namespace o2::aod
+{
 namespace col
 {
 DECLARE_SOA_COLUMN(X, x, float);
@@ -30,6 +31,7 @@ DECLARE_SOA_COLUMN(D, d, float);
 
 DECLARE_SOA_TABLE(XY, "AOD", "XY", col::X, col::Y);
 DECLARE_SOA_TABLE(ZD, "AOD", "ZD", col::Z, col::D);
+} // namespace o2::aod
 
 TEST_CASE("TestJoinedTablesContains")
 {
@@ -51,8 +53,8 @@ TEST_CASE("TestJoinedTablesContains")
   REQUIRE(tests.asArrowTable()->num_columns() != 0);
   REQUIRE(tests.asArrowTable()->num_columns() ==
           tXY->num_columns() + tZD->num_columns());
-  auto tests2 = join<o2::framework::OriginEnc{"JOIN"}>(XY{tXY}, ZD{tZD});
-  static_assert(std::is_same_v<Test::table_t, decltype(tests2)>,
+  auto tests2 = join(XY{tXY}, ZD{tZD});
+  static_assert(std::same_as<Test::table_t, decltype(tests2)::table_t>,
                 "Joined tables should have the same type, regardless how we construct them");
 
   using FullTracks = o2::soa::Join<o2::aod::Tracks, o2::aod::TracksExtra, o2::aod::TracksCov>;
diff --git a/Framework/Core/test/test_AnalysisTask.cxx b/Framework/Core/test/test_AnalysisTask.cxx
index fcb115c14bc97..9153aa8c40098 100644
--- a/Framework/Core/test/test_AnalysisTask.cxx
+++ b/Framework/Core/test/test_AnalysisTask.cxx
@@ -21,6 +21,7 @@ using namespace o2::framework;
 
 namespace o2::aod
 {
+O2HASH("TestA/0");
 namespace test
 {
 DECLARE_SOA_COLUMN(X, x, float);
@@ -30,9 +31,12 @@ DECLARE_SOA_COLUMN(Foo, foo, float);
 DECLARE_SOA_COLUMN(Bar, bar, float);
 DECLARE_SOA_COLUMN(EventProperty, eventProperty, float);
 DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](float x, float y) { return x + y; });
+DECLARE_SOA_EXPRESSION_COLUMN(Sqfoo, sqfoo, float, nsqrt(test::foo));
 } // namespace test
+
 DECLARE_SOA_TABLE(Foos, "AOD", "FOO",
                   test::Foo);
+DECLARE_SOA_EXTENDED_TABLE(Fooss, Foos, "FOOS", 0, test::Sqfoo);
 DECLARE_SOA_TABLE(Bars, "AOD", "BAR",
                   test::Bar);
 DECLARE_SOA_TABLE(FooBars, "AOD", "FOOBAR",
@@ -42,6 +46,27 @@ DECLARE_SOA_TABLE(XYZ, "AOD", "XYZ",
                   test::X, test::Y, test::Z);
 DECLARE_SOA_TABLE(Events, "AOD", "EVENTS",
                   test::EventProperty);
+
+DECLARE_SOA_TABLE(Roots, "AOD", "ROOTS", test::Foo);
+
+namespace idx
+{
+DECLARE_SOA_INDEX_COLUMN(Root, root);
+}
+
+DECLARE_SOA_TABLE(B1s, "AOD", "B1", idx::RootId, test::X);
+DECLARE_SOA_TABLE(B2s, "AOD", "B2", idx::RootId, test::Y);
+DECLARE_SOA_TABLE(B3s, "AOD", "B3", idx::RootId, test::Z);
+
+namespace idx
+{
+DECLARE_SOA_INDEX_COLUMN(B1, b1);
+DECLARE_SOA_INDEX_COLUMN(B2, b2);
+DECLARE_SOA_INDEX_COLUMN(B3, b3);
+} // namespace idx
+
+DECLARE_SOA_INDEX_TABLE(Bs, Roots, "BS", idx::RootId, idx::B1Id, idx::B2Id, idx::B3Id);
+
 } // namespace o2::aod
 
 struct ATask {
@@ -49,10 +74,16 @@ struct ATask {
 
   void process(o2::aod::Track const&)
   {
-    foobars(0.01102005, 0.27092016); // dummy value for phi for now...
   }
 };
 
+struct ATaskconsumer {
+  Spawns<aod::Fooss> foos;
+  Builds<aod::Bs> bs;
+
+  void init(InitContext&) {}
+};
+
 struct BTask {
   void process(o2::aod::Collision const&, o2::soa::Join<o2::aod::Tracks, o2::aod::TracksExtra, o2::aod::TracksCov> const&, o2::aod::AmbiguousTracks const&, o2::aod::Calos const&, o2::aod::CaloTriggers const&)
   {
@@ -159,21 +190,29 @@ TEST_CASE("AdaptorCompilation")
   auto cfgc = makeEmptyConfigContext();
 
   REQUIRE(brace_constructible_size<ATask>() == 1);
-  auto task1 = adaptAnalysisTask<ATask>(*cfgc, TaskName{"test1"});
-  REQUIRE(task1.inputs.size() == 2);
-  REQUIRE(task1.outputs.size() == 1);
-  REQUIRE(task1.inputs[1].binding == std::string("Tracks"));
-  REQUIRE(task1.inputs[0].binding == std::string("TracksExtension"));
-  REQUIRE(task1.outputs[0].binding.value == std::string("FooBars"));
+  auto task1ng = adaptAnalysisTask<ATask>(*cfgc, TaskName{"test1"});
+  REQUIRE(task1ng.inputs.size() == 2);
+  REQUIRE(task1ng.outputs.size() == 1);
+  REQUIRE(task1ng.inputs[1].binding == std::string("TracksExtension"));
+  REQUIRE(task1ng.inputs[0].binding == std::string("Tracks"));
+  REQUIRE(task1ng.outputs[0].binding.value == std::string("FooBars"));
+
+  auto task1ngc = adaptAnalysisTask<ATaskconsumer>(*cfgc);
+  REQUIRE(task1ngc.inputs.size() == 5);
+  REQUIRE(task1ngc.inputs[0].binding == "Foos");
+  REQUIRE(task1ngc.inputs[1].binding == "Roots");
+  REQUIRE(task1ngc.inputs[2].binding == "B1s");
+  REQUIRE(task1ngc.inputs[3].binding == "B2s");
+  REQUIRE(task1ngc.inputs[4].binding == "B3s");
 
   auto task2 = adaptAnalysisTask<BTask>(*cfgc, TaskName{"test2"});
   REQUIRE(task2.inputs.size() == 10);
-  REQUIRE(task2.inputs[1].binding == "TracksExtension");
-  REQUIRE(task2.inputs[2].binding == "Tracks");
-  REQUIRE(task2.inputs[3].binding == "TracksExtra_001Extension");
-  REQUIRE(task2.inputs[4].binding == "TracksExtra");
-  REQUIRE(task2.inputs[5].binding == "TracksCovExtension");
-  REQUIRE(task2.inputs[6].binding == "TracksCov");
+  REQUIRE(task2.inputs[2].binding == "TracksExtension");
+  REQUIRE(task2.inputs[1].binding == "Tracks");
+  REQUIRE(task2.inputs[4].binding == "TracksExtra_001Extension");
+  REQUIRE(task2.inputs[3].binding == "TracksExtra");
+  REQUIRE(task2.inputs[6].binding == "TracksCovExtension");
+  REQUIRE(task2.inputs[5].binding == "TracksCov");
   REQUIRE(task2.inputs[7].binding == "AmbiguousTracks");
   REQUIRE(task2.inputs[8].binding == "Calos");
   REQUIRE(task2.inputs[9].binding == "CaloTriggers");
@@ -182,30 +221,33 @@ TEST_CASE("AdaptorCompilation")
   auto task3 = adaptAnalysisTask<CTask>(*cfgc, TaskName{"test3"});
   REQUIRE(task3.inputs.size() == 3);
   REQUIRE(task3.inputs[0].binding == "Collisions_001");
-  REQUIRE(task3.inputs[2].binding == "Tracks");
-  REQUIRE(task3.inputs[1].binding == "TracksExtension");
+  REQUIRE(task3.inputs[1].binding == "Tracks");
+  REQUIRE(task3.inputs[2].binding == "TracksExtension");
 
   auto task4 = adaptAnalysisTask<DTask>(*cfgc, TaskName{"test4"});
   REQUIRE(task4.inputs.size() == 2);
-  REQUIRE(task4.inputs[1].binding == "Tracks");
-  REQUIRE(task4.inputs[0].binding == "TracksExtension");
+  REQUIRE(task4.inputs[0].binding == "Tracks");
+  REQUIRE(task4.inputs[1].binding == "TracksExtension");
 
   auto task5 = adaptAnalysisTask<ETask>(*cfgc, TaskName{"test5"});
   REQUIRE(task5.inputs.size() == 1);
   REQUIRE(task5.inputs[0].binding == "FooBars");
 
-  auto task6 = adaptAnalysisTask<FTask>(*cfgc, TaskName{"test6"});
-  REQUIRE(task6.inputs.size() == 1);
-  REQUIRE(task6.inputs[0].binding == "FooBars");
+  auto task6ng = adaptAnalysisTask<FTask>(*cfgc, TaskName{"test6"});
+  REQUIRE(task6ng.inputs.size() == 1);
+  REQUIRE(task6ng.inputs[0].binding == "FooBars");
 
-  auto task7 = adaptAnalysisTask<GTask>(*cfgc, TaskName{"test7"});
-  REQUIRE(task7.inputs.size() == 3);
+  auto task7ng = adaptAnalysisTask<GTask>(*cfgc, TaskName{"test7"});
+  REQUIRE(task7ng.inputs.size() == 3);
+  REQUIRE(task7ng.inputs[0].binding == "Foos");
+  REQUIRE(task7ng.inputs[1].binding == "Bars");
+  REQUIRE(task7ng.inputs[2].binding == "XYZ");
 
-  auto task8 = adaptAnalysisTask<HTask>(*cfgc, TaskName{"test8"});
-  REQUIRE(task8.inputs.size() == 3);
+  auto task8ng = adaptAnalysisTask<HTask>(*cfgc, TaskName{"test8"});
+  REQUIRE(task8ng.inputs.size() == 3);
 
-  auto task9 = adaptAnalysisTask<ITask>(*cfgc, TaskName{"test9"});
-  REQUIRE(task9.inputs.size() == 4);
+  auto task9ng = adaptAnalysisTask<ITask>(*cfgc, TaskName{"test9"});
+  REQUIRE(task9ng.inputs.size() == 4);
 
   auto task10 = adaptAnalysisTask<JTask>(*cfgc, TaskName{"test10"});
   REQUIRE(task10.inputs.size() == 1);
@@ -233,7 +275,7 @@ TEST_CASE("TestPartitionIteration")
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
 
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, aod::test::X, aod::test::Y>;
+  using TestA = soa::InPlaceTable<"TestA/0"_h, o2::soa::Index<>, aod::test::X, aod::test::Y>;
   using FilteredTest = o2::soa::Filtered<TestA>;
   using PartitionTest = Partition<TestA>;
   using PartitionFilteredTest = Partition<o2::soa::Filtered<TestA>>;
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 77d4c72eca095..8b08a9a38aa63 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -184,7 +184,7 @@ TEST_CASE("TestGandivaTreeCreation")
   auto projector_b = createProjector(schema2, ptespecs, resfield2);
   auto fields = o2::soa::createFieldsFromColumns(o2::aod::Tracks::persistent_columns_t{});
   auto schema_p = std::make_shared<arrow::Schema>(fields);
-  auto projector_alt = o2::framework::expressions::createProjectors(o2::framework::pack<o2::aod::track::Pt>{}, fields, schema_p);
+  auto projector_alt = o2::framework::expressions::createProjectors(o2::framework::pack<o2::aod::track::Pt>{}, {resfield2}, schema_p);
 
   Filter bitwiseFilter = (o2::aod::track::flags & static_cast<uint32_t>(o2::aod::track::TPCrefit)) != 0u;
   auto bwf = createOperations(bitwiseFilter);
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 82e92679d5e67..8ce5170e89cb7 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -65,13 +65,13 @@ DECLARE_SOA_TABLE(TrksU, "AOD", "TRKSU",
                   test::Y,
                   test::Z);
 
-DECLARE_SOA_TABLE(TrksXU, "AOD", "TRKSX",
+DECLARE_SOA_TABLE(TrksXU, "AOD", "TRKSXU",
                   unsorted::EventId,
                   test::X);
-DECLARE_SOA_TABLE(TrksYU, "AOD", "TRKSY",
+DECLARE_SOA_TABLE(TrksYU, "AOD", "TRKSYU",
                   unsorted::EventId,
                   test::Y);
-DECLARE_SOA_TABLE(TrksZU, "AOD", "TRKSZ",
+DECLARE_SOA_TABLE(TrksZU, "AOD", "TRKSZU",
                   unsorted::EventId,
                   test::Z);
 
@@ -560,21 +560,21 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
     for (auto& thing : ts) {
       if (thing.has_part()) {
         auto part = thing.part_as<FilteredParts>();
-        REQUIRE(std::is_same_v<std::decay_t<decltype(part)>::parent_t, FilteredParts>);
+        REQUIRE(std::same_as<std::decay_t<decltype(part)>::parent_t, FilteredParts>);
         auto rs = part.relatives_as<std::decay_t<decltype(part)::parent_t>>();
-        REQUIRE(std::is_same_v<std::decay_t<decltype(rs)>, FilteredParts>);
+        REQUIRE(std::same_as<std::decay_t<decltype(rs)>, FilteredParts>);
         for (auto& r : rs) {
-          REQUIRE(std::is_same_v<std::decay_t<decltype(r)>::parent_t, FilteredParts>);
+          REQUIRE(std::same_as<std::decay_t<decltype(r)>::parent_t, FilteredParts>);
           auto rss = r.relatives_as<std::decay_t<decltype(r)>::parent_t>();
-          REQUIRE(std::is_same_v<std::decay_t<decltype(rss)>, FilteredParts>);
+          REQUIRE(std::same_as<std::decay_t<decltype(rss)>, FilteredParts>);
           for (auto& rr : rss) {
-            REQUIRE(std::is_same_v<std::decay_t<decltype(rr)>::parent_t, FilteredParts>);
+            REQUIRE(std::same_as<std::decay_t<decltype(rr)>::parent_t, FilteredParts>);
             auto rsss = rr.relatives_as<std::decay_t<decltype(rr)>::parent_t>();
-            REQUIRE(std::is_same_v<std::decay_t<decltype(rsss)>, FilteredParts>);
+            REQUIRE(std::same_as<std::decay_t<decltype(rsss)>, FilteredParts>);
             for (auto& rrr : rsss) {
-              REQUIRE(std::is_same_v<std::decay_t<decltype(rrr)>::parent_t, FilteredParts>);
+              REQUIRE(std::same_as<std::decay_t<decltype(rrr)>::parent_t, FilteredParts>);
               auto rssss = rrr.relatives_as<std::decay_t<decltype(rrr)>::parent_t>();
-              REQUIRE(std::is_same_v<std::decay_t<decltype(rssss)>, FilteredParts>);
+              REQUIRE(std::same_as<std::decay_t<decltype(rssss)>, FilteredParts>);
             }
           }
         }
diff --git a/Framework/Core/test/test_HistogramRegistry.cxx b/Framework/Core/test/test_HistogramRegistry.cxx
index 9df713696a7e0..fe470683a1614 100644
--- a/Framework/Core/test/test_HistogramRegistry.cxx
+++ b/Framework/Core/test/test_HistogramRegistry.cxx
@@ -84,7 +84,7 @@ TEST_CASE("HistogramRegistryExpressionFill")
   rowWriterA(0, 7.0f, -4.0f);
   auto tableA = builderA.finalize();
   REQUIRE(tableA->num_rows() == 8);
-  using TestA = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, o2::soa::Index<>, test::X, test::Y>;
+  using TestA = o2::soa::InPlaceTable<"A/1"_h, o2::soa::Index<>, test::X, test::Y>;
   TestA tests{tableA};
   REQUIRE(8 == tests.size());
 
diff --git a/Framework/Core/test/test_IndexBuilder.cxx b/Framework/Core/test/test_IndexBuilder.cxx
index 1a9912fc9c540..ea9f715f20c8a 100644
--- a/Framework/Core/test/test_IndexBuilder.cxx
+++ b/Framework/Core/test/test_IndexBuilder.cxx
@@ -16,9 +16,11 @@
 using namespace o2::framework;
 using namespace arrow;
 using namespace o2::soa;
+using namespace o2::aod;
 
-DECLARE_SOA_METADATA();
-DECLARE_SOA_VERSIONING();
+namespace o2::aod
+{
+O2ORIGIN("TST");
 namespace coords
 {
 DECLARE_SOA_COLUMN_FULL(X, x, float, "x");
@@ -48,16 +50,17 @@ DECLARE_SOA_COLUMN_FULL(Category, category, int32_t, "category");
 } // namespace extra_3
 DECLARE_SOA_TABLE(Categorys, "TST", "Categories", Index<>, extra_3::PointId, extra_3::Category);
 
-namespace indices
+namespace test_indices
 {
 DECLARE_SOA_INDEX_COLUMN(Point, point);
 DECLARE_SOA_INDEX_COLUMN(Distance, distance);
 DECLARE_SOA_INDEX_COLUMN(Flag, flag);
 DECLARE_SOA_INDEX_COLUMN(Category, category);
-} // namespace indices
+} // namespace test_indices
 
-DECLARE_SOA_TABLE(IDXs, "TST", "Index", Index<>, indices::PointId, indices::DistanceId, indices::FlagId, indices::CategoryId);
-DECLARE_SOA_TABLE(IDX2s, "TST", "Index2", Index<>, indices::DistanceId, indices::PointId, indices::FlagId, indices::CategoryId);
+DECLARE_SOA_INDEX_TABLE(IDXs, Points, "Index1", test_indices::PointId, test_indices::DistanceId, test_indices::FlagId, test_indices::CategoryId);
+DECLARE_SOA_INDEX_TABLE(IDX2s, Points, "Index2", test_indices::DistanceId, test_indices::PointId, test_indices::FlagId, test_indices::CategoryId);
+} // namespace o2::aod
 
 TEST_CASE("TestIndexBuilder")
 {
@@ -99,7 +102,8 @@ TEST_CASE("TestIndexBuilder")
   auto t4 = b4.finalize();
   Categorys st4{t4};
 
-  auto t5 = IndexBuilder<Exclusive>::indexBuilder<Points>("test1a", {t1, t2, t3, t4}, typename IDXs::persistent_columns_t{}, o2::framework::pack<Points, Distances, Flags, Categorys>{});
+  using m1 = MetadataTrait<o2::aod::Hash<"Index1/0"_h>>::metadata;
+  auto t5 = IndexBuilder<Exclusive>::indexBuilder<Points, m1::sources.size(), m1::sources>("test1a", {t1, t2, t3, t4}, typename IDXs::persistent_columns_t{});
   REQUIRE(t5->num_rows() == 4);
   IDXs idxt{t5};
   idxt.bindExternalIndices(&st1, &st2, &st3, &st4);
@@ -109,9 +113,10 @@ TEST_CASE("TestIndexBuilder")
     REQUIRE(row.category().pointId() == row.pointId());
   }
 
-  auto t6 = IndexBuilder<Sparse>::indexBuilder<Points>("test3", {t2, t1, t3, t4}, typename IDX2s::persistent_columns_t{}, o2::framework::pack<Distances, Points, Flags, Categorys>{});
+  using m2 = MetadataTrait<o2::aod::Hash<"Index2/0"_h>>::metadata;
+  auto t6 = IndexBuilder<Sparse>::indexBuilder<Points, m2::sources.size(), m2::sources>("test3", {t2, t1, t3, t4}, typename IDX2s::persistent_columns_t{});
   REQUIRE(t6->num_rows() == st2.size());
-  IDXs idxs{t6};
+  IDX2s idxs{t6};
   std::array<int, 7> fs{0, 1, 2, -1, -1, 4, -1};
   std::array<int, 7> cs{0, 1, 2, -1, 5, 6, -1};
   idxs.bindExternalIndices(&st1, &st2, &st3, &st4);
@@ -131,22 +136,25 @@ TEST_CASE("TestIndexBuilder")
   }
 }
 
+namespace o2::aod
+{
 namespace extra_4
 {
 DECLARE_SOA_COLUMN_FULL(Bin, bin, int, "bin");
 DECLARE_SOA_COLUMN_FULL(Color, color, int, "color");
 } // namespace extra_4
 
-DECLARE_SOA_TABLE(BinnedPoints, "TST", "BinnedPoints", Index<>, extra_4::Bin, indices::PointId);
-DECLARE_SOA_TABLE(ColoredPoints, "TST", "ColoredPoints", Index<>, extra_4::Color, indices::PointId);
+DECLARE_SOA_TABLE(BinnedPoints, "TST", "BinnedPoints", Index<>, extra_4::Bin, test_indices::PointId);
+DECLARE_SOA_TABLE(ColoredPoints, "TST", "ColoredPoints", Index<>, extra_4::Color, test_indices::PointId);
 
-namespace indices
+namespace test_indices
 {
 DECLARE_SOA_SLICE_INDEX_COLUMN(BinnedPoint, binsSlice);
 DECLARE_SOA_ARRAY_INDEX_COLUMN(ColoredPoint, colorsList);
-} // namespace indices
+} // namespace test_indices
 
-DECLARE_SOA_TABLE(IDX3s, "TST", "Index3", Index<>, indices::PointId, indices::BinnedPointIdSlice, indices::ColoredPointIds);
+DECLARE_SOA_INDEX_TABLE(IDX3s, Points, "Index3", test_indices::PointId, test_indices::BinnedPointIdSlice, test_indices::ColoredPointIds);
+} // namespace o2::aod
 
 TEST_CASE("AdvancedIndexTables")
 {
@@ -204,7 +212,8 @@ TEST_CASE("AdvancedIndexTables")
                                                    {14, 34},
                                                    {8, 31, 42, 46, 58}}};
 
-  auto t3 = IndexBuilder<Sparse>::indexBuilder<Points>("test4", {t1, t2, tc}, typename IDX3s::persistent_columns_t{}, o2::framework::pack<Points, BinnedPoints, ColoredPoints>{});
+  using m3 = MetadataTrait<o2::aod::Hash<"Index3/0"_h>>::metadata;
+  auto t3 = IndexBuilder<Sparse>::indexBuilder<Points, m3::sources.size(), m3::sources>("test4", {t1, t2, tc}, typename IDX3s::persistent_columns_t{});
   REQUIRE(t3->num_rows() == st1.size());
   IDX3s idxs{t3};
   idxs.bindExternalIndices(&st1, &st2, &st3);
@@ -219,8 +228,8 @@ TEST_CASE("AdvancedIndexTables")
       }
     }
     auto colors = row.colorsList();
-    REQUIRE(colors.size() == colorsizes[count]);
-    for (auto j = 0; j < colors.size(); ++j) {
+    REQUIRE(colors.size() == (size_t)colorsizes[count]);
+    for (auto j = 0U; j < colors.size(); ++j) {
       REQUIRE(colors[j].color() == colorvalues[count][j]);
     }
     ++count;
diff --git a/Framework/Core/test/test_Root2ArrowTable.cxx b/Framework/Core/test/test_Root2ArrowTable.cxx
index 2b0ab9154250c..8440e942903a5 100644
--- a/Framework/Core/test/test_Root2ArrowTable.cxx
+++ b/Framework/Core/test/test_Root2ArrowTable.cxx
@@ -124,7 +124,6 @@ TEST_CASE("RootTree2Table")
 
 namespace o2::aod
 {
-DECLARE_SOA_VERSIONING();
 namespace test
 {
 DECLARE_SOA_COLUMN_FULL(Px, px, float, "px");
diff --git a/Framework/Core/test/test_StaticFor.cxx b/Framework/Core/test/test_StaticFor.cxx
index ee66c5b4aaf5b..e37ca9cd0b278 100644
--- a/Framework/Core/test/test_StaticFor.cxx
+++ b/Framework/Core/test/test_StaticFor.cxx
@@ -26,21 +26,21 @@ TEST_CASE("TestStaticFor")
 {
   // check if it is actually static
   static_for<0, 0>([&](auto i) {
-    static_assert(std::is_same_v<decltype(i), std::integral_constant<int, 0>>);
+    static_assert(std::same_as<decltype(i), std::integral_constant<int, 0>>);
 
-    static_assert(std::is_same_v<decltype(i.value), const int>);
+    static_assert(std::same_as<decltype(i.value), const int>);
     REQUIRE(i.value == 0);
     REQUIRE(i == 0);
 
     // the following checks will fail
-    // static_assert(std::is_same_v<decltype(i), std::integral_constant<int, 1>>);
+    // static_assert(std::same_as<decltype(i), std::integral_constant<int, 1>>);
     // REQUIRE(i.value ==  1);;
     // REQUIRE(i ==  1);;
   });
 
   // dont start at 0
   static_for<5, 5>([&](auto i) {
-    static_assert(std::is_same_v<decltype(i), std::integral_constant<int, 5>>);
+    static_assert(std::same_as<decltype(i), std::integral_constant<int, 5>>);
   });
 
   // check if argument can be used as non-type template argument
diff --git a/Framework/Core/test/test_StringHelpers.cxx b/Framework/Core/test/test_StringHelpers.cxx
index 4d3f43f0a845d..44f3fffd4efee 100644
--- a/Framework/Core/test/test_StringHelpers.cxx
+++ b/Framework/Core/test/test_StringHelpers.cxx
@@ -37,7 +37,7 @@ TEST_CASE("StringHelpersConstStr")
 
   auto myConstStr = CONST_STR("helloWorld");
   printString(myConstStr);
-  static_assert(std::is_same_v<decltype(myConstStr), ConstStr<'h', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd'>>);
+  static_assert(std::same_as<decltype(myConstStr), ConstStr<'h', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd'>>);
   static_assert(myConstStr.hash == (uint32_t)942280617);
   REQUIRE(myConstStr.hash == compile_time_hash("helloWorld"));
 
@@ -47,7 +47,7 @@ TEST_CASE("StringHelpersConstStr")
 
   auto myConstStr2 = CONST_STR("hello") + CONST_STR("Universe");
   printString(myConstStr2);
-  static_assert(std::is_same_v<decltype(myConstStr2), ConstStr<'h', 'e', 'l', 'l', 'o', 'U', 'n', 'i', 'v', 'e', 'r', 's', 'e'>>);
+  static_assert(std::same_as<decltype(myConstStr2), ConstStr<'h', 'e', 'l', 'l', 'o', 'U', 'n', 'i', 'v', 'e', 'r', 's', 'e'>>);
 
   enum ParticleSpecies {
     kPion,
diff --git a/Framework/Core/test/test_TableBuilder.cxx b/Framework/Core/test/test_TableBuilder.cxx
index ca978b4ba8e46..b08fee5ad4e6a 100644
--- a/Framework/Core/test/test_TableBuilder.cxx
+++ b/Framework/Core/test/test_TableBuilder.cxx
@@ -11,17 +11,13 @@
 
 #include <catch_amalgamated.hpp>
 
-#include "Framework/Logger.h"
 #include "Framework/TableBuilder.h"
-#include "Framework/TableConsumer.h"
-#include "Framework/DataAllocator.h"
-#include "Framework/OutputRoute.h"
+#include "Framework/Output.h"
 #include <arrow/table.h>
 #include <arrow/ipc/writer.h>
 #include <arrow/io/memory.h>
 #include <arrow/ipc/writer.h>
 #include <arrow/ipc/reader.h>
-#include "../src/ArrowDebugHelpers.h"
 
 using namespace o2::framework;
 
@@ -34,8 +30,8 @@ DECLARE_SOA_COLUMN_FULL(Y, y, uint64_t, "y");
 DECLARE_SOA_COLUMN_FULL(Pos, pos, int[4], "pos");
 } // namespace test2
 
-using TestTable = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test2::X, test2::Y>;
-using ArrayTable = o2::soa::Table<o2::framework::OriginEnc{"AOD"}, test2::Pos>;
+using TestTable = o2::soa::InPlaceTable<0, test2::X, test2::Y>;
+using ArrayTable = o2::soa::InPlaceTable<0, test2::Pos>;
 
 TEST_CASE("TestTableBuilder")
 {
@@ -184,7 +180,7 @@ TEST_CASE("TestTableBuilderBulk")
   REQUIRE(table->schema()->field(0)->type()->id() == arrow::int32()->id());
   REQUIRE(table->schema()->field(1)->type()->id() == arrow::int32()->id());
 
-  for (size_t i = 0; i < 8; ++i) {
+  for (int64_t i = 0; i < 8; ++i) {
     auto p = std::dynamic_pointer_cast<arrow::NumericArray<arrow::Int32Type>>(table->column(0)->chunk(0));
     REQUIRE(p->Value(i) == i);
   }
diff --git a/Framework/Core/test/test_TableSpawner.cxx b/Framework/Core/test/test_TableSpawner.cxx
new file mode 100644
index 0000000000000..3d8879d115213
--- /dev/null
+++ b/Framework/Core/test/test_TableSpawner.cxx
@@ -0,0 +1,74 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <catch_amalgamated.hpp>
+#include "Framework/AnalysisHelpers.h"
+
+#include <Framework/AnalysisDataModel.h>
+#include <Framework/TableBuilder.h>
+
+using namespace o2::framework;
+using namespace o2::soa;
+using namespace o2::aod;
+
+namespace o2::aod
+{
+namespace test
+{
+DECLARE_SOA_COLUMN(X, x, float);
+DECLARE_SOA_COLUMN(Y, y, float);
+DECLARE_SOA_COLUMN(Z, z, float);
+DECLARE_SOA_EXPRESSION_COLUMN(Rsq, rsq, float, test::x* test::x + test::y * test::y + test::z * test::z);
+DECLARE_SOA_EXPRESSION_COLUMN(Sin, sin, float, test::x / nsqrt(test::x * test::x + test::y * test::y));
+} // namespace test
+
+DECLARE_SOA_TABLE(Points, "AOD", "PTSNG", test::X, test::Y, test::Z);
+DECLARE_SOA_EXTENDED_TABLE(ExPoints, Points, "EXPTSNG", 0, test::Rsq, test::Sin);
+} // namespace o2::aod
+
+TEST_CASE("TestTableSpawner")
+{
+  TableBuilder b1;
+  auto w1 = b1.cursor<Points>();
+
+  for (auto i = 1; i < 10; ++i) {
+    w1(0, i * 2., i * 3., i * 4.);
+  }
+
+  auto t1 = b1.finalize();
+  Points st1{t1};
+
+  auto expoints_a = o2::soa::Extend<o2::aod::Points, test::Rsq, test::Sin>(st1);
+  auto extension = ExPointsExtension{o2::framework::spawner<o2::aod::Hash<"EXPTSNG/0"_h>>(t1, o2::aod::Hash<"ExPoints"_h>::str)};
+  auto expoints = ExPoints{{t1, extension.asArrowTable()}, 0};
+
+  REQUIRE(expoints_a.size() == 9);
+  REQUIRE(extension.size() == 9);
+  REQUIRE(expoints.size() == 9);
+
+  auto rex = extension.begin();
+  auto rexp = expoints.begin();
+  auto rexp_a = expoints_a.begin();
+
+  for (auto i = 1; i < 10; ++i) {
+    float rsq = i * i * 4 + i * i * 9 + i * i * 16;
+    float sin = i * 2 / std::sqrt(i * i * 4 + i * i * 9);
+    REQUIRE(rexp_a.rsq() == rsq);
+    REQUIRE(rex.rsq() == rsq);
+    REQUIRE(rexp.rsq() == rsq);
+    REQUIRE(rexp_a.sin() == sin);
+    REQUIRE(rex.sin() == sin);
+    REQUIRE(rexp.sin() == sin);
+    ++rex;
+    ++rexp;
+    ++rexp_a;
+  }
+}
diff --git a/Framework/Core/test/test_TreeToTable.cxx b/Framework/Core/test/test_TreeToTable.cxx
index 4746eead57c1e..4f3429a5bba62 100644
--- a/Framework/Core/test/test_TreeToTable.cxx
+++ b/Framework/Core/test/test_TreeToTable.cxx
@@ -157,7 +157,6 @@ TEST_CASE("TreeToTableConversion")
 
 namespace o2::aod
 {
-DECLARE_SOA_VERSIONING();
 namespace cols
 {
 DECLARE_SOA_COLUMN(Ivec, ivec, std::vector<int>);
diff --git a/Framework/Core/test/test_TypeTraits.cxx b/Framework/Core/test/test_TypeTraits.cxx
index 38849e7b1978a..5d38ca33c137c 100644
--- a/Framework/Core/test/test_TypeTraits.cxx
+++ b/Framework/Core/test/test_TypeTraits.cxx
@@ -156,18 +156,18 @@ struct NoBar : NoFooFoo<int> {
 
 TEST_CASE("BaseOfTemplate")
 {
-  constexpr bool t = is_base_of_template_v<std::vector, std::vector<int>>;
+  constexpr bool t = base_of_template<std::vector, std::vector<int>>;
   static_assert(t == true, "This should be true");
 
-  constexpr bool t2 = is_base_of_template_v<std::vector, int>;
+  constexpr bool t2 = base_of_template<std::vector, int>;
   static_assert(t2 == false, "This should be true");
 
-  constexpr bool t3 = is_base_of_template_v<FooFoo, Bar>;
+  constexpr bool t3 = base_of_template<FooFoo, Bar>;
   static_assert(t3 == true, "This should be true");
 
-  constexpr bool t4 = is_base_of_template_v<FooFoo, NoBar>;
+  constexpr bool t4 = base_of_template<FooFoo, NoBar>;
   static_assert(t4 == false, "This should be false");
 
-  constexpr bool t5 = is_base_of_template_v<NoFooFoo, NoBar>;
+  constexpr bool t5 = base_of_template<NoFooFoo, NoBar>;
   static_assert(t5 == true, "This should be true");
 }
diff --git a/Framework/Foundation/include/Framework/Pack.h b/Framework/Foundation/include/Framework/Pack.h
index 8daccab4880a4..2355ffed6b35b 100644
--- a/Framework/Foundation/include/Framework/Pack.h
+++ b/Framework/Foundation/include/Framework/Pack.h
@@ -39,7 +39,6 @@ struct pack_element<I, pack<Ts...>> {
   using type = __type_pack_element<I, Ts...>;
 };
 #else
-
 // recursive case
 template <std::size_t I, typename Head, typename... Tail>
 struct pack_element<I, pack<Head, Tail...>>
@@ -209,7 +208,7 @@ using filtered_pack = std::decay_t<decltype(filter_pack<Condition>(pack<>{}, pac
 template <typename T, typename... Us>
 bool consteval has_type(framework::pack<Us...>)
 {
-  return (std::is_same_v<T, Us> || ...);
+  return (std::same_as<T, Us> || ...);
 }
 
 template <typename T, typename P>