diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a28b2da927..f23d8da8489 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@
 * Expose `realm_object_get_parent` in the C API (PR [#5851](https://github.com/realm/realm-core/pull/5851))
 * Expose `realm_list_find` in the C API (PR [#5848](https://github.com/realm/realm-core/pull/5848))
 * Expose `Group::remove_table` in the C API (PR [#5860](https://github.com/realm/realm-core/pull/5860))
+* Cut the runtime of aggregate operations on large dictionaries in half ([PR #5864](https://github.com/realm/realm-core/pull/5864)).
+* Improve performance of aggregate operations on collections of objects by 2x to 10x ([PR #5864](https://github.com/realm/realm-core/pull/5864)).
 
 ### Fixed
 * <How do the end-user experience this issue? what was the impact?> ([#????](https://github.com/realm/realm-core/issues/????), since v?.?.?)
@@ -23,7 +25,7 @@
 * Throw exception if `Realm::Convert` tries to convert to flexible sync. ([#5798](https://github.com/realm/realm-core/issues/5798), since v11.16.0).
 
 ### Breaking changes
-* None.
+* The typed aggregation functions (e.g. `minimum_int`) on `Table`, `TableView`, and `Query` have been removed and replaced with simpler untyped versions which return `Mixed`. This does not effect SDKs which only used them via the Object Store types.
 
 ### Compatibility
 * Fileformat: Generates files with format v22. Reads and automatically upgrade from fileformat v5.
diff --git a/src/realm/CMakeLists.txt b/src/realm/CMakeLists.txt
index 6f211fb0a51..d1b40710fe9 100644
--- a/src/realm/CMakeLists.txt
+++ b/src/realm/CMakeLists.txt
@@ -265,6 +265,39 @@ set(REALM_INSTALL_HEADERS
     metrics/transaction_info.hpp
 ) # REALM_INSTALL_HEADERS
 
+set(REALM_NOINST_HEADERS
+    link_translator.hpp
+    object_converter.hpp
+    query_conditions_tpl.hpp
+    util/cf_str.hpp
+    util/circular_buffer.hpp
+    util/cli_args.hpp
+    util/copy_dir_recursive.hpp
+    util/demangle.hpp
+    util/duplicating_logger.hpp
+    util/enum.hpp
+    util/ez_websocket.hpp
+    util/file_is_regular.hpp
+    util/from_chars.hpp
+    util/get_file_size.hpp
+    util/json_parser.hpp
+    util/load_file.hpp
+    util/network_ssl.hpp
+    util/parent_dir.hpp
+    util/platform_info.hpp
+    util/quote.hpp
+    util/random.hpp
+    util/resource_limits.hpp
+    util/scratch_allocator.hpp
+    util/signal_blocker.hpp
+    util/substitute.hpp
+    util/thread_exec_guard.hpp
+    util/time.hpp
+    util/timestamp_formatter.hpp
+    util/timestamp_logger.hpp
+    util/value_reset_guard.hpp
+) # REALM_NOINST_HEADERS
+
 list(APPEND REALM_SOURCES
     metrics/metrics.cpp
     metrics/metric_timer.cpp
@@ -279,6 +312,7 @@ add_library(Storage STATIC
     ${REALM_SOURCES}
     ${UTIL_SOURCES}
     ${REALM_INSTALL_HEADERS}
+    ${REALM_NOINST_HEADERS}
     ${REALM_OBJECT_FILES}
     $<TARGET_OBJECTS:Bid>
 )
diff --git a/src/realm/dictionary.cpp b/src/realm/dictionary.cpp
index df4876f2445..bdcebacc9ff 100644
--- a/src/realm/dictionary.cpp
+++ b/src/realm/dictionary.cpp
@@ -393,28 +393,67 @@ size_t Dictionary::find_any_key(Mixed key) const noexcept
     return m_clusters->get_ndx_with_key(get_internal_obj_key(key), key);
 }
 
+namespace {
+bool can_minmax(DataType type)
+{
+    switch (type) {
+        case type_Int:
+        case type_Float:
+        case type_Double:
+        case type_Decimal:
+        case type_Mixed:
+        case type_Timestamp:
+            return true;
+        default:
+            return false;
+    }
+}
+bool can_sum(DataType type)
+{
+    switch (type) {
+        case type_Int:
+        case type_Float:
+        case type_Double:
+        case type_Decimal:
+        case type_Mixed:
+            return true;
+        default:
+            return false;
+    }
+}
+} // anonymous namespace
+
 util::Optional<Mixed> Dictionary::min(size_t* return_ndx) const
 {
+    if (!can_minmax(get_value_data_type())) {
+        return std::nullopt;
+    }
     if (update()) {
         return m_clusters->min(return_ndx);
     }
     if (return_ndx)
-        *return_ndx = realm::npos;
+        *return_ndx = realm::not_found;
     return Mixed{};
 }
 
 util::Optional<Mixed> Dictionary::max(size_t* return_ndx) const
 {
+    if (!can_minmax(get_value_data_type())) {
+        return std::nullopt;
+    }
     if (update()) {
         return m_clusters->max(return_ndx);
     }
     if (return_ndx)
-        *return_ndx = realm::npos;
+        *return_ndx = realm::not_found;
     return Mixed{};
 }
 
 util::Optional<Mixed> Dictionary::sum(size_t* return_cnt) const
 {
+    if (!can_sum(get_value_data_type())) {
+        return std::nullopt;
+    }
     if (update()) {
         return m_clusters->sum(return_cnt, get_value_data_type());
     }
@@ -425,6 +464,9 @@ util::Optional<Mixed> Dictionary::sum(size_t* return_cnt) const
 
 util::Optional<Mixed> Dictionary::avg(size_t* return_cnt) const
 {
+    if (!can_sum(get_value_data_type())) {
+        return std::nullopt;
+    }
     if (update()) {
         return m_clusters->avg(return_cnt, get_value_data_type());
     }
@@ -1124,14 +1166,6 @@ ObjKey DictionaryLinkValues::get_key(size_t ndx) const
     return {};
 }
 
-// In contrast to a link list and a link set, a dictionary can contain null links.
-// This is because the corresponding key may contain useful information by itself.
-bool DictionaryLinkValues::is_obj_valid(size_t ndx) const noexcept
-{
-    Mixed val = m_source.get_any(ndx);
-    return val.is_type(type_TypedLink);
-}
-
 Obj DictionaryLinkValues::get_object(size_t row_ndx) const
 {
     Mixed val = m_source.get_any(row_ndx);
diff --git a/src/realm/dictionary.hpp b/src/realm/dictionary.hpp
index fc96e1a118a..34d374815a9 100644
--- a/src/realm/dictionary.hpp
+++ b/src/realm/dictionary.hpp
@@ -239,7 +239,6 @@ class DictionaryLinkValues final : public ObjCollectionBase<CollectionBase> {
 
     // Overrides of ObjList:
     ObjKey get_key(size_t ndx) const final;
-    bool is_obj_valid(size_t ndx) const noexcept final;
     Obj get_object(size_t row_ndx) const final;
 
     // Overrides of CollectionBase, these simply forward to the underlying dictionary.
diff --git a/src/realm/list.hpp b/src/realm/list.hpp
index 70e4583587f..a5489fef6db 100644
--- a/src/realm/list.hpp
+++ b/src/realm/list.hpp
@@ -414,11 +414,6 @@ class LnkLst final : public ObjCollectionBase<LstBase> {
     void swap(size_t ndx1, size_t ndx2) final;
 
     // Overriding members of ObjList:
-    bool is_obj_valid(size_t) const noexcept final
-    {
-        // A link list cannot contain null values
-        return true;
-    }
     Obj get_object(size_t ndx) const final
     {
         ObjKey key = this->get(ndx);
diff --git a/src/realm/mixed.cpp b/src/realm/mixed.cpp
index 8703cfd5030..ad6a5737fc2 100644
--- a/src/realm/mixed.cpp
+++ b/src/realm/mixed.cpp
@@ -222,7 +222,7 @@ bool Mixed::accumulate_numeric_to(Decimal128& destination) const
     return did_accumulate;
 }
 
-int Mixed::compare(const Mixed& b) const
+int Mixed::compare(const Mixed& b) const noexcept
 {
     // Observe! Changing this function breaks the file format for Set<Mixed>
 
diff --git a/src/realm/mixed.hpp b/src/realm/mixed.hpp
index c1f5c8a0ccf..0349f68ff45 100644
--- a/src/realm/mixed.hpp
+++ b/src/realm/mixed.hpp
@@ -209,32 +209,32 @@ class Mixed {
     bool is_unresolved_link() const;
     bool is_same_type(const Mixed& b) const;
     // Will use utf8_compare for strings
-    int compare(const Mixed& b) const;
+    int compare(const Mixed& b) const noexcept;
     // Will compare strings as arrays of signed chars
     int compare_signed(const Mixed& b) const;
-    bool operator==(const Mixed& other) const
+    friend bool operator==(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) == 0;
+        return a.compare(b) == 0;
     }
-    bool operator!=(const Mixed& other) const
+    friend bool operator!=(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) != 0;
+        return a.compare(b) != 0;
     }
-    bool operator<(const Mixed& other) const
+    friend bool operator<(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) < 0;
+        return a.compare(b) < 0;
     }
-    bool operator>(const Mixed& other) const
+    friend bool operator>(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) > 0;
+        return a.compare(b) > 0;
     }
-    bool operator<=(const Mixed& other) const
+    friend bool operator<=(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) <= 0;
+        return a.compare(b) <= 0;
     }
-    bool operator>=(const Mixed& other) const
+    friend bool operator>=(const Mixed& a, const Mixed& b) noexcept
     {
-        return compare(other) >= 0;
+        return a.compare(b) >= 0;
     }
 
     Mixed operator+(const Mixed&) const;
diff --git a/src/realm/obj.hpp b/src/realm/obj.hpp
index b36359ac942..ad1b0c9be83 100644
--- a/src/realm/obj.hpp
+++ b/src/realm/obj.hpp
@@ -94,7 +94,7 @@ enum class UpdateStatus {
 // 'Object' would have been a better name, but it clashes with a class in ObjectStore
 class Obj {
 public:
-    Obj()
+    constexpr Obj()
         : m_table(nullptr)
         , m_row_ndx(size_t(-1))
         , m_storage_version(-1)
diff --git a/src/realm/obj_list.hpp b/src/realm/obj_list.hpp
index 35f46434f64..6ea00cabb53 100644
--- a/src/realm/obj_list.hpp
+++ b/src/realm/obj_list.hpp
@@ -34,7 +34,6 @@ class ObjList {
     virtual size_t size() const = 0;
     virtual TableRef get_target_table() const = 0;
     virtual ObjKey get_key(size_t ndx) const = 0;
-    virtual bool is_obj_valid(size_t ndx) const noexcept = 0;
     virtual Obj get_object(size_t row_ndx) const = 0;
     virtual void sync_if_needed() const = 0;
     virtual void get_dependencies(TableVersions&) const = 0;
@@ -64,18 +63,13 @@ class ObjList {
     {
         return get_object(ndx);
     }
-    virtual Obj try_get_object(size_t row_ndx) const noexcept
-    {
-        REALM_ASSERT(row_ndx < size());
-        return is_obj_valid(row_ndx) ? get_object(row_ndx) : Obj();
-    }
 
     template <class F>
     void for_each(F func) const
     {
         auto sz = size();
         for (size_t i = 0; i < sz; i++) {
-            auto o = try_get_object(i);
+            auto o = get_object(i);
             if (o && func(o) == IteratorControl::Stop)
                 return;
         }
@@ -86,7 +80,7 @@ class ObjList {
     {
         auto sz = size();
         for (size_t i = 0; i < sz; i++) {
-            auto o = try_get_object(i);
+            auto o = get_object(i);
             if (o) {
                 T v = o.get<T>(column_key);
                 if (v == value)
diff --git a/src/realm/object-store/collection.cpp b/src/realm/object-store/collection.cpp
index 09d0ac951fe..fd9dd2a8bc9 100644
--- a/src/realm/object-store/collection.cpp
+++ b/src/realm/object-store/collection.cpp
@@ -198,6 +198,25 @@ Results Collection::snapshot() const
     return as_results().snapshot();
 }
 
+std::optional<Mixed> Collection::max(ColKey col) const
+{
+    return as_results().max(col);
+}
+
+util::Optional<Mixed> Collection::min(ColKey col) const
+{
+    return as_results().min(col);
+}
+
+Mixed Collection::sum(ColKey col) const
+{
+    return *as_results().sum(col);
+}
+
+util::Optional<Mixed> Collection::average(ColKey col) const
+{
+    return as_results().average(col);
+}
 
 NotificationToken Collection::add_notification_callback(CollectionChangeCallback callback,
                                                         KeyPathArray key_path_array) &
diff --git a/src/realm/object-store/collection.hpp b/src/realm/object-store/collection.hpp
index 7bb43240d42..fe970f00e39 100644
--- a/src/realm/object-store/collection.hpp
+++ b/src/realm/object-store/collection.hpp
@@ -101,6 +101,15 @@ class Collection {
     Results sort(SortDescriptor order) const;
     Results sort(std::vector<std::pair<std::string, bool>> const& keypaths) const;
 
+    // Get the min/max/average/sum of the given column
+    // All but sum() returns none when collection is empty, and sum() returns 0
+    // Throws UnsupportedColumnTypeException for sum/average on timestamp or non-numeric column
+    // Throws OutOfBoundsIndexException for an out-of-bounds column
+    util::Optional<Mixed> max(ColKey column = {}) const;
+    util::Optional<Mixed> min(ColKey column = {}) const;
+    util::Optional<Mixed> average(ColKey column = {}) const;
+    Mixed sum(ColKey column = {}) const;
+
     /**
      * Adds a `CollectionChangeCallback` to this `Collection`. The `CollectionChangeCallback` is exectuted when
      * insertions, modifications or deletions happen on this `Collection`.
diff --git a/src/realm/object-store/list.cpp b/src/realm/object-store/list.cpp
index 36076272072..7fbc5f3d97f 100644
--- a/src/realm/object-store/list.cpp
+++ b/src/realm/object-store/list.cpp
@@ -295,89 +295,6 @@ Results List::filter(Query q) const
     return Results(m_realm, std::dynamic_pointer_cast<LnkLst>(m_coll_base), get_query().and_query(std::move(q)));
 }
 
-template <class, class = void>
-struct HasMinmaxType : std::false_type {
-};
-template <class T>
-struct HasMinmaxType<T, std::void_t<typename ColumnTypeTraits<T>::minmax_type>> : std::true_type {
-};
-
-template <class, class = void>
-struct HasSumType : std::false_type {
-};
-template <class T>
-struct HasSumType<T, std::void_t<typename ColumnTypeTraits<T>::sum_type>> : std::true_type {
-};
-
-template <bool cond>
-struct If;
-
-template <>
-struct If<true> {
-    template <typename T, typename Then, typename Else>
-    static auto call(T self, Then&& fn, Else&&)
-    {
-        return fn(self);
-    }
-};
-template <>
-struct If<false> {
-    template <typename T, typename Then, typename Else>
-    static auto call(T, Then&&, Else&& fn)
-    {
-        return fn();
-    }
-};
-
-util::Optional<Mixed> List::max(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().max(col);
-    size_t out_ndx = not_found;
-    auto result = list_base().max(&out_ndx);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(list_base().get_col_key(), list_base().get_table(), "max");
-    }
-    return out_ndx == not_found ? none : result;
-}
-
-util::Optional<Mixed> List::min(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().min(col);
-
-    size_t out_ndx = not_found;
-    auto result = list_base().min(&out_ndx);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(list_base().get_col_key(), list_base().get_table(), "min");
-    }
-    return out_ndx == not_found ? none : result;
-}
-
-Mixed List::sum(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return *as_results().sum(col);
-
-    auto result = list_base().sum();
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(list_base().get_col_key(), list_base().get_table(), "sum");
-    }
-    return *result;
-}
-
-util::Optional<Mixed> List::average(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().average(col);
-    size_t count = 0;
-    auto result = list_base().avg(&count);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(list_base().get_col_key(), list_base().get_table(), "average");
-    }
-    return count == 0 ? none : result;
-}
-
 bool List::operator==(List const& rgt) const noexcept
 {
     return list_base().get_table() == rgt.list_base().get_table() &&
diff --git a/src/realm/object-store/list.hpp b/src/realm/object-store/list.hpp
index fb2b6b25688..1f12b2c43a4 100644
--- a/src/realm/object-store/list.hpp
+++ b/src/realm/object-store/list.hpp
@@ -86,16 +86,6 @@ class List : public object_store::Collection {
     // Equivalent to producing a thread-safe reference and resolving it in the frozen realm.
     List freeze(std::shared_ptr<Realm> const& frozen_realm) const;
 
-    // Get the min/max/average/sum of the given column
-    // All but sum() returns none when there are zero matching rows
-    // sum() returns 0,
-    // Throws UnsupportedColumnTypeException for sum/average on timestamp or non-numeric column
-    // Throws OutOfBoundsIndexException for an out-of-bounds column
-    util::Optional<Mixed> max(ColKey column = {}) const;
-    util::Optional<Mixed> min(ColKey column = {}) const;
-    util::Optional<Mixed> average(ColKey column = {}) const;
-    Mixed sum(ColKey column = {}) const;
-
     bool operator==(List const& rgt) const noexcept;
 
     template <typename Context>
diff --git a/src/realm/object-store/results.cpp b/src/realm/object-store/results.cpp
index cfd1eb35bd8..1f64c2274e5 100644
--- a/src/realm/object-store/results.cpp
+++ b/src/realm/object-store/results.cpp
@@ -403,7 +403,7 @@ util::Optional<Obj> Results::try_get(size_t row_ndx)
         case Mode::TableView:
             if (row_ndx >= m_table_view.size())
                 break;
-            return m_table_view.try_get_object(row_ndx);
+            return m_table_view.get_object(row_ndx);
     }
     return util::none;
 }
@@ -547,286 +547,24 @@ size_t Results::index_of(Query&& q)
     return row ? index_of(const_cast<Table&>(*m_table).get_object(row)) : not_found;
 }
 
-DataType Results::prepare_for_aggregate(ColKey column, const char* name)
-{
-    DataType type;
-    switch (m_mode) {
-        case Mode::Table:
-            type = m_table->get_column_type(column);
-            break;
-        case Mode::Collection:
-            type = m_collection->get_table()->get_column_type(m_collection->get_col_key());
-            if (type != type_LinkList && type != type_Link)
-                break;
-            m_query = do_get_query();
-            m_mode = Mode::Query;
-            REALM_FALLTHROUGH;
-        case Mode::Query:
-        case Mode::TableView:
-            ensure_up_to_date();
-            type = m_table->get_column_type(column);
-            break;
-        default:
-            REALM_COMPILER_HINT_UNREACHABLE();
-    }
-    switch (type) {
-        case type_Timestamp:
-        case type_Double:
-        case type_Float:
-        case type_Int:
-        case type_Decimal:
-        case type_Mixed:
-            break;
-        default:
-            if (m_mode == Mode::Collection) {
-                throw UnsupportedColumnTypeException(m_collection->get_col_key(), m_collection->get_table(), name);
-            }
-            else {
-                throw UnsupportedColumnTypeException{column, *m_table, name};
-            }
-    }
-    return type;
-}
-
 namespace {
-template <typename T, typename Table>
-struct AggregateHelper;
-
-template <typename Table>
-struct AggregateHelper<int64_t, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
-    {
-        return table.minimum_int(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
-    {
-        return table.maximum_int(col, obj);
-    }
-    Mixed sum(ColKey col)
-    {
-        return table.sum_int(col);
-    }
-    Mixed avg(ColKey col, size_t* count)
-    {
-        return table.average_int(col, count);
-    }
-};
-
-template <typename Table>
-struct AggregateHelper<double, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
-    {
-        return table.minimum_double(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
-    {
-        return table.maximum_double(col, obj);
-    }
-    Mixed sum(ColKey col)
-    {
-        return table.sum_double(col);
-    }
-    Mixed avg(ColKey col, size_t* count)
-    {
-        return table.average_double(col, count);
-    }
-};
-
-template <typename Table>
-struct AggregateHelper<float, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
-    {
-        return table.minimum_float(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
+struct CollectionAggregateAdaptor {
+    const CollectionBase& list;
+    util::Optional<Mixed> min(ColKey)
     {
-        return table.maximum_float(col, obj);
+        return list.min();
     }
-    Mixed sum(ColKey col)
-    {
-        return table.sum_float(col);
-    }
-    Mixed avg(ColKey col, size_t* count)
-    {
-        return table.average_float(col, count);
-    }
-};
-
-template <typename Table>
-struct AggregateHelper<Timestamp, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
-    {
-        return table.minimum_timestamp(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
-    {
-        return table.maximum_timestamp(col, obj);
-    }
-    Mixed sum(ColKey col)
-    {
-        throw Results::UnsupportedColumnTypeException{col, table, "sum"};
-    }
-    Mixed avg(ColKey col, size_t*)
-    {
-        throw Results::UnsupportedColumnTypeException{col, table, "avg"};
-    }
-};
-
-template <typename Table>
-struct AggregateHelper<Decimal128, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
-    {
-        return table.minimum_decimal(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
-    {
-        return table.maximum_decimal(col, obj);
-    }
-    Mixed sum(ColKey col)
-    {
-        return table.sum_decimal(col);
-    }
-    Mixed avg(ColKey col, size_t* count)
-    {
-        return table.average_decimal(col, count);
-    }
-};
-
-template <typename Table>
-struct AggregateHelper<Mixed, Table> {
-    Table& table;
-    Mixed min(ColKey col, ObjKey* obj)
+    util::Optional<Mixed> max(ColKey)
     {
-        return table.minimum_mixed(col, obj);
-    }
-    Mixed max(ColKey col, ObjKey* obj)
-    {
-        return table.maximum_mixed(col, obj);
-    }
-    Mixed sum(ColKey col)
-    {
-        return table.sum_mixed(col);
-    }
-    Mixed avg(ColKey col, size_t* count)
-    {
-        return table.average_mixed(col, count);
-    }
-};
-
-
-struct ListAggregateHelper {
-    CollectionBase& list;
-    util::Optional<Mixed> min(ColKey, size_t* ndx)
-    {
-        return list.min(ndx);
-    }
-    util::Optional<Mixed> max(ColKey, size_t* ndx)
-    {
-        return list.max(ndx);
+        return list.max();
     }
     util::Optional<Mixed> sum(ColKey)
     {
         return list.sum();
     }
-    util::Optional<Mixed> avg(ColKey, size_t* count)
-    {
-        return list.avg(count);
-    }
-};
-
-template <>
-struct AggregateHelper<int64_t, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
+    util::Optional<Mixed> avg(ColKey)
     {
-    }
-};
-template <>
-struct AggregateHelper<double, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
-    {
-    }
-};
-template <>
-struct AggregateHelper<float, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
-    {
-    }
-};
-template <>
-struct AggregateHelper<Decimal128, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
-    {
-    }
-};
-
-template <>
-struct AggregateHelper<Timestamp, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
-    {
-    }
-    Mixed sum(ColKey)
-    {
-        throw Results::UnsupportedColumnTypeException{list.get_col_key(), *list.get_table(), "sum"};
-    }
-    Mixed avg(ColKey, size_t*)
-    {
-        throw Results::UnsupportedColumnTypeException{list.get_col_key(), *list.get_table(), "avg"};
-    }
-};
-
-template <>
-struct AggregateHelper<Mixed, CollectionBase&> : ListAggregateHelper {
-    AggregateHelper(CollectionBase& l)
-        : ListAggregateHelper{l}
-    {
-    }
-};
-
-template <typename Table, typename Func>
-util::Optional<Mixed> call_with_helper(Func&& func, Table&& table, DataType type)
-{
-    switch (type) {
-        case type_Timestamp:
-            return func(AggregateHelper<Timestamp, Table>{table});
-        case type_Double:
-            return func(AggregateHelper<double, Table>{table});
-        case type_Float:
-            return func(AggregateHelper<Float, Table>{table});
-        case type_Int:
-            return func(AggregateHelper<Int, Table>{table});
-        case type_Decimal:
-            return func(AggregateHelper<Decimal128, Table>{table});
-        case type_Mixed:
-            return func(AggregateHelper<Mixed, Table>{table});
-        default:
-            REALM_COMPILER_HINT_UNREACHABLE();
-    }
-}
-
-struct ReturnIndexHelper {
-    ObjKey key;
-    size_t index = npos;
-    operator ObjKey*()
-    {
-        return &key;
-    }
-    operator size_t*()
-    {
-        return &index;
-    }
-    operator bool()
-    {
-        return key || index != npos;
+        return list.avg();
     }
 };
 } // anonymous namespace
@@ -839,49 +577,70 @@ util::Optional<Mixed> Results::aggregate(ColKey column, const char* name, Aggreg
     if (!m_table && !m_collection)
         return none;
 
-    auto type = prepare_for_aggregate(column, name);
+    ensure_up_to_date();
+    std::optional<Mixed> ret;
     switch (m_mode) {
         case Mode::Table:
-            return call_with_helper(func, *m_table, type);
+            ret = func(*m_table);
+            break;
+        case Mode::Query:
+            ret = func(m_query);
+            break;
         case Mode::Collection:
-            return call_with_helper(func, *m_collection, type);
+            if (do_get_type() != PropertyType::Object)
+                ret = func(CollectionAggregateAdaptor{*m_collection});
+            else
+                ret = func(do_get_query());
+            break;
         default:
-            return call_with_helper(func, m_table_view, type);
+            ret = func(m_table_view);
+            break;
+    }
+
+    // `none` indicates that it's an unsupported operation for the column type.
+    // `some(null)` indicates that there's no rows in the thing being aggregated
+    // Any other value is just the result to return
+    if (ret) {
+        return ret->is_null() ? std::nullopt : std::optional(*ret);
+    }
+
+    // We need to report the column and table actually being aggregated on,
+    // which is the collection if it's not a link collection and the target
+    // of the links otherwise
+    if (m_mode == Mode::Collection && do_get_type() != PropertyType::Object) {
+        throw UnsupportedColumnTypeException(m_collection->get_col_key(), m_collection->get_table(), name);
+    }
+    else {
+        throw UnsupportedColumnTypeException{column, *m_table, name};
     }
 }
 
 util::Optional<Mixed> Results::max(ColKey column)
 {
-    ReturnIndexHelper return_ndx;
-    auto results = aggregate(column, "max", [&](auto&& helper) {
-        return helper.max(column, return_ndx);
+    return aggregate(column, "max", [column](auto&& helper) {
+        return helper.max(column);
     });
-    return return_ndx ? results : none;
 }
 
 util::Optional<Mixed> Results::min(ColKey column)
 {
-    ReturnIndexHelper return_ndx;
-    auto results = aggregate(column, "min", [&](auto&& helper) {
-        return helper.min(column, return_ndx);
+    return aggregate(column, "min", [column](auto&& helper) {
+        return helper.min(column);
     });
-    return return_ndx ? results : none;
 }
 
 util::Optional<Mixed> Results::sum(ColKey column)
 {
-    return aggregate(column, "sum", [&](auto&& helper) {
+    return aggregate(column, "sum", [column](auto&& helper) {
         return helper.sum(column);
     });
 }
 
 util::Optional<Mixed> Results::average(ColKey column)
 {
-    size_t value_count = 0;
-    auto results = aggregate(column, "avg", [&](auto&& helper) {
-        return helper.avg(column, &value_count);
+    return aggregate(column, "avg", [column](auto&& helper) {
+        return helper.avg(column);
     });
-    return value_count == 0 ? none : results;
 }
 
 void Results::clear()
@@ -983,11 +742,9 @@ Query Results::do_get_query() const
             if (const_cast<Query&>(m_query).get_table())
                 return m_query;
 
-            // A TableView has an associated Query if it was produced by Query::find_all. This is indicated
-            // by TableView::get_query returning a Query with a non-null table.
-            Query query = m_table_view.get_query();
-            if (query.get_table()) {
-                return query;
+            // A TableView has an associated Query if it was produced by Query::find_all
+            if (auto& query = m_table_view.get_query()) {
+                return *query;
             }
 
             // The TableView has no associated query so create one with no conditions that is restricted
@@ -995,7 +752,7 @@ Query Results::do_get_query() const
             if (m_update_policy == UpdatePolicy::Auto) {
                 m_table_view.sync_if_needed();
             }
-            return Query(m_table, std::unique_ptr<TableView>(new TableView(m_table_view)));
+            return Query(m_table, std::make_unique<TableView>(m_table_view));
         }
         case Mode::Collection:
             if (auto list = dynamic_cast<ObjList*>(m_collection.get())) {
diff --git a/src/realm/object-store/results.hpp b/src/realm/object-store/results.hpp
index 5d261b4d455..f8d1cd979ef 100644
--- a/src/realm/object-store/results.hpp
+++ b/src/realm/object-store/results.hpp
@@ -399,7 +399,6 @@ class Results {
 
     template <typename AggregateFunction>
     util::Optional<Mixed> aggregate(ColKey column, const char* name, AggregateFunction&& func) REQUIRES(!m_mutex);
-    DataType prepare_for_aggregate(ColKey column, const char* name) REQUIRES(m_mutex);
 
     template <typename Fn>
     auto dispatch(Fn&&) const REQUIRES(!m_mutex);
diff --git a/src/realm/object-store/set.cpp b/src/realm/object-store/set.cpp
index 4a26d86c3ac..92c814d44fe 100644
--- a/src/realm/object-store/set.cpp
+++ b/src/realm/object-store/set.cpp
@@ -84,55 +84,6 @@ std::pair<size_t, bool> Set::remove(const T& value)
     return as<T>().erase(value);
 }
 
-util::Optional<Mixed> Set::max(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().max(col);
-    size_t out_ndx = not_found;
-    auto result = set_base().max(&out_ndx);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(set_base().get_col_key(), set_base().get_table(), "max");
-    }
-    return out_ndx == not_found ? none : result;
-}
-
-util::Optional<Mixed> Set::min(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().min(col);
-
-    size_t out_ndx = not_found;
-    auto result = set_base().min(&out_ndx);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(set_base().get_col_key(), set_base().get_table(), "min");
-    }
-    return out_ndx == not_found ? none : result;
-}
-
-Mixed Set::sum(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return *as_results().sum(col);
-
-    auto result = set_base().sum();
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(set_base().get_col_key(), set_base().get_table(), "sum");
-    }
-    return *result;
-}
-
-util::Optional<Mixed> Set::average(ColKey col) const
-{
-    if (get_type() == PropertyType::Object)
-        return as_results().average(col);
-    size_t count = 0;
-    auto result = set_base().avg(&count);
-    if (!result) {
-        throw Results::UnsupportedColumnTypeException(set_base().get_col_key(), set_base().get_table(), "average");
-    }
-    return count == 0 ? none : result;
-}
-
 bool Set::operator==(const Set& rgt) const noexcept
 {
     return set_base().get_table() == rgt.set_base().get_table() &&
diff --git a/src/realm/object-store/set.hpp b/src/realm/object-store/set.hpp
index 8663a894ca5..edcb59faa0e 100644
--- a/src/realm/object-store/set.hpp
+++ b/src/realm/object-store/set.hpp
@@ -91,16 +91,6 @@ class Set : public Collection {
 
     Set freeze(const std::shared_ptr<Realm>& realm) const;
 
-    // Get the min/max/average/sum of the given column
-    // All but sum() returns none when there are zero matching rows
-    // sum() returns 0,
-    // Throws UnsupportedColumnTypeException for sum/average on timestamp or non-numeric column
-    // Throws OutOfBoundsIndexException for an out-of-bounds column
-    util::Optional<Mixed> max(ColKey column = {}) const;
-    util::Optional<Mixed> min(ColKey column = {}) const;
-    util::Optional<Mixed> average(ColKey column = {}) const;
-    Mixed sum(ColKey column = {}) const;
-
     bool is_subset_of(const Collection& rhs) const;
     bool is_strict_subset_of(const Collection& rhs) const;
     bool is_superset_of(const Collection& rhs) const;
diff --git a/src/realm/query.cpp b/src/realm/query.cpp
index a92dded20e5..af939ecd055 100644
--- a/src/realm/query.cpp
+++ b/src/realm/query.cpp
@@ -22,16 +22,15 @@
 #include <realm/column_fwd.hpp>
 #include <realm/transaction.hpp>
 #include <realm/dictionary.hpp>
+#include <realm/query_conditions_tpl.hpp>
 #include <realm/query_engine.hpp>
 #include <realm/query_expression.hpp>
 #include <realm/table_view.hpp>
-#include <realm/table_tpl.hpp>
 #include <realm/set.hpp>
 #include <realm/array_integer_tpl.hpp>
 
 #include <algorithm>
 
-
 using namespace realm;
 using namespace realm::metrics;
 
@@ -949,7 +948,7 @@ bool Query::eval_object(const Obj& obj) const
 
 
 template <typename T>
-void Query::aggregate(QueryStateBase& st, ColKey column_key, size_t* resultcount, ObjKey* return_ndx) const
+void Query::aggregate(QueryStateBase& st, ColKey column_key) const
 {
     using LeafType = typename ColumnTypeTraits<T>::cluster_leaf_type;
 
@@ -1008,14 +1007,6 @@ void Query::aggregate(QueryStateBase& st, ColKey column_key, size_t* resultcount
             });
         }
     }
-
-    if (resultcount) {
-        *resultcount = st.match_count();
-    }
-
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
 }
 
 size_t Query::find_best_node(ParentNode* pn) const
@@ -1064,260 +1055,40 @@ void Query::aggregate_internal(ParentNode* pn, QueryStateBase* st, size_t start,
     }
 }
 
+// Aggregates
 
-// Sum
-
-int64_t Query::sum_int(ColKey column_key) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
-#endif
-
-    QueryStateSum<int64_t> st;
-    if (m_table->is_nullable(column_key)) {
-        aggregate<util::Optional<int64_t>>(st, column_key);
-    }
-    else {
-        aggregate<int64_t>(st, column_key);
-    }
-    return st.result_sum();
-}
-double Query::sum_float(ColKey column_key) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
-#endif
-
-    QueryStateSum<float> st;
-    aggregate<float>(st, column_key);
-    return st.result_sum();
-}
-double Query::sum_double(ColKey column_key) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
-#endif
-    QueryStateSum<double> st;
-    aggregate<double>(st, column_key);
-    return st.result_sum();
-}
-
-Decimal128 Query::sum_decimal128(ColKey column_key) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
-#endif
-
-    QueryStateSum<Decimal128> st;
-    aggregate<Decimal128>(st, column_key);
-    return st.result_sum();
-}
-
-Decimal128 Query::sum_mixed(ColKey column_key) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
-#endif
-
-    QueryStateSum<Mixed> st;
-    aggregate<Mixed>(st, column_key);
-    return st.result_sum();
-}
-
-// Maximum
-
-int64_t Query::maximum_int(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<int64_t> st;
-    if (m_table->is_nullable(column_key)) {
-        aggregate<util::Optional<int64_t>>(st, column_key, nullptr, return_ndx);
-    }
-    else {
-        aggregate<int64_t>(st, column_key, nullptr, return_ndx);
-    }
-    return st.get_max();
-}
-
-float Query::maximum_float(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<float> st;
-    aggregate<float>(st, column_key, nullptr, return_ndx);
-    return st.get_max();
-}
-double Query::maximum_double(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<double> st;
-    aggregate<double>(st, column_key, nullptr, return_ndx);
-    return st.get_max();
-}
-
-Decimal128 Query::maximum_decimal128(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<Decimal128> st;
-    aggregate<Decimal128>(st, column_key, nullptr, return_ndx);
-    return st.get_max();
-}
-
-Mixed Query::maximum_mixed(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<Mixed> st;
-    aggregate<Mixed>(st, column_key, nullptr, return_ndx);
-    return st.get_max();
-}
-
-Timestamp Query::maximum_timestamp(ColKey column_key, ObjKey* return_ndx)
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
-#endif
-
-    QueryStateMax<Timestamp> st;
-    aggregate<Timestamp>(st, column_key, nullptr, return_ndx);
-    return st.get_max();
-}
-
-// Minimum
-
-int64_t Query::minimum_int(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
-#endif
-
-    QueryStateMin<int64_t> st;
-    if (m_table->is_nullable(column_key)) {
-        aggregate<util::Optional<int64_t>>(st, column_key, nullptr, return_ndx);
-    }
-    else {
-        aggregate<int64_t>(st, column_key, nullptr, return_ndx);
-    }
-    return st.get_min();
-}
-float Query::minimum_float(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
-#endif
-
-    QueryStateMin<float> st;
-    aggregate<float>(st, column_key, nullptr, return_ndx);
-    return st.get_min();
-}
-double Query::minimum_double(ColKey column_key, ObjKey* return_ndx) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
-#endif
-
-    QueryStateMin<double> st;
-    aggregate<double>(st, column_key, nullptr, return_ndx);
-    return st.get_min();
-}
-
-Timestamp Query::minimum_timestamp(ColKey column_key, ObjKey* return_ndx)
+std::optional<Mixed> Query::sum(ColKey col_key) const
 {
 #if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
+    auto metric_timer = QueryInfo::track(this, QueryInfo::type_Sum);
 #endif
-
-    QueryStateMin<Timestamp> st;
-    aggregate<Timestamp>(st, column_key, nullptr, return_ndx);
-    return st.get_min();
+    return AggregateHelper<Query>::sum(*m_table, *this, col_key);
 }
 
-Decimal128 Query::minimum_decimal128(ColKey column_key, ObjKey* return_ndx) const
+std::optional<Mixed> Query::avg(ColKey col_key, size_t* value_count) const
 {
 #if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
+    auto metric_timer = QueryInfo::track(this, QueryInfo::type_Average);
 #endif
-
-    QueryStateMin<Decimal128> st;
-    aggregate<Decimal128>(st, column_key, nullptr, return_ndx);
-    return st.get_min();
+    return AggregateHelper<Query>::avg(*m_table, *this, col_key, value_count);
 }
 
-Mixed Query::minimum_mixed(ColKey column_key, ObjKey* return_ndx) const
+std::optional<Mixed> Query::min(ColKey col_key, ObjKey* return_ndx) const
 {
 #if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
+    auto metric_timer = QueryInfo::track(this, QueryInfo::type_Minimum);
 #endif
-
-    QueryStateMin<Mixed> st;
-    aggregate<Mixed>(st, column_key, nullptr, return_ndx);
-    return st.get_min();
+    return AggregateHelper<Query>::min(*m_table, *this, col_key, return_ndx);
 }
 
-// Average
-
-template <typename T, typename R>
-R Query::average(ColKey column_key, size_t* resultcount) const
+std::optional<Mixed> Query::max(ColKey col_key, ObjKey* return_ndx) const
 {
 #if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Average);
+    auto metric_timer = QueryInfo::track(this, QueryInfo::type_Maximum);
 #endif
-    size_t resultcount2 = 0;
-    QueryStateSum<typename util::RemoveOptional<T>::type> st;
-    aggregate<T>(st, column_key, &resultcount2);
-    R sum1 = R(st.result_sum());
-    R avg1{};
-    if (resultcount2 != 0)
-        avg1 = sum1 / resultcount2;
-    if (resultcount)
-        *resultcount = resultcount2;
-    return avg1;
+    return AggregateHelper<Query>::max(*m_table, *this, col_key, return_ndx);
 }
 
-double Query::average_int(ColKey column_key, size_t* resultcount) const
-{
-    if (m_table->is_nullable(column_key)) {
-        return average<util::Optional<int64_t>>(column_key, resultcount);
-    }
-    return average<int64_t>(column_key, resultcount);
-}
-double Query::average_float(ColKey column_key, size_t* resultcount) const
-{
-    return average<float>(column_key, resultcount);
-}
-double Query::average_double(ColKey column_key, size_t* resultcount) const
-{
-    return average<double>(column_key, resultcount);
-}
-Decimal128 Query::average_decimal128(ColKey column_key, size_t* resultcount) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Average);
-#endif
-    return average<Decimal128>(column_key, resultcount);
-}
-Decimal128 Query::average_mixed(ColKey column_key, size_t* resultcount) const
-{
-#if REALM_METRICS
-    std::unique_ptr<MetricTimer> metric_timer = QueryInfo::track(this, QueryInfo::type_Average);
-#endif
-    return average<Mixed>(column_key, resultcount);
-}
-
-
 // Grouping
 Query& Query::group()
 {
@@ -1418,7 +1189,7 @@ ObjKey Query::find() const
     if (m_view) {
         size_t sz = m_view->size();
         for (size_t i = 0; i < sz; i++) {
-            const Obj obj = m_view->try_get_object(i);
+            const Obj obj = m_view->get_object(i);
             if (eval_object(obj)) {
                 return obj.get_key();
             }
@@ -1457,7 +1228,7 @@ void Query::do_find_all(TableView& ret, size_t limit) const
     if (m_view) {
         size_t sz = m_view->size();
         for (size_t t = 0; t < sz && ret.size() < limit; t++) {
-            const Obj obj = m_view->try_get_object(t);
+            const Obj obj = m_view->get_object(t);
             if (eval_object(obj)) {
                 ret.m_key_values.add(obj.get_key());
             }
diff --git a/src/realm/query.hpp b/src/realm/query.hpp
index fc45606f8ce..2a512aa9cad 100644
--- a/src/realm/query.hpp
+++ b/src/realm/query.hpp
@@ -257,28 +257,14 @@ class Query final {
     size_t count() const;
     TableView find_all(const DescriptorOrdering& descriptor) const;
     size_t count(const DescriptorOrdering& descriptor) const;
-    int64_t sum_int(ColKey column_key) const;
-    double average_int(ColKey column_key, size_t* resultcount = nullptr) const;
-    int64_t maximum_int(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    int64_t minimum_int(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    double sum_float(ColKey column_key) const;
-    double average_float(ColKey column_key, size_t* resultcount = nullptr) const;
-    float maximum_float(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    float minimum_float(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    double sum_double(ColKey column_key) const;
-    double average_double(ColKey column_key, size_t* resultcount = nullptr) const;
-    double maximum_double(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    double minimum_double(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    Timestamp maximum_timestamp(ColKey column_key, ObjKey* return_ndx = nullptr);
-    Timestamp minimum_timestamp(ColKey column_key, ObjKey* return_ndx = nullptr);
-    Decimal128 sum_decimal128(ColKey column_key) const;
-    Decimal128 maximum_decimal128(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    Decimal128 minimum_decimal128(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    Decimal128 average_decimal128(ColKey column_key, size_t* resultcount = nullptr) const;
-    Decimal128 sum_mixed(ColKey column_key) const;
-    Mixed maximum_mixed(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    Mixed minimum_mixed(ColKey column_key, ObjKey* return_ndx = nullptr) const;
-    Decimal128 average_mixed(ColKey column_key, size_t* resultcount = nullptr) const;
+
+    // Aggregates return nullopt if the operation is not supported on the given column
+    // Everything but `sum` returns `some(null)` if there are no non-null values
+    // Sum returns `some(0)` if there are no non-null values.
+    std::optional<Mixed> sum(ColKey col_key) const;
+    std::optional<Mixed> min(ColKey col_key, ObjKey* = nullptr) const;
+    std::optional<Mixed> max(ColKey col_key, ObjKey* = nullptr) const;
+    std::optional<Mixed> avg(ColKey col_key, size_t* value_count = nullptr) const;
 
     // Deletion
     size_t remove() const;
@@ -358,13 +344,8 @@ class Query final {
     template <typename TConditionFunction>
     Query& add_size_condition(ColKey column_key, int64_t value);
 
-    template <typename T,
-              typename R = typename aggregate_operations::Average<typename util::RemoveOptional<T>::type>::ResultType>
-    R average(ColKey column_key, size_t* resultcount = nullptr) const;
-
     template <typename T>
-    void aggregate(QueryStateBase& st, ColKey column_key, size_t* resultcount = nullptr,
-                   ObjKey* return_ndx = nullptr) const;
+    void aggregate(QueryStateBase& st, ColKey column_key) const;
 
     size_t find_best_node(ParentNode* pn) const;
     void aggregate_internal(ParentNode* pn, QueryStateBase* st, size_t start, size_t end,
@@ -391,6 +372,8 @@ class Query final {
     friend class SubQueryCount;
     friend class PrimitiveListCount;
     friend class metrics::QueryInfo;
+    template <class>
+    friend class AggregateHelper;
 
     std::string error_code;
 
diff --git a/src/realm/query_conditions_tpl.hpp b/src/realm/query_conditions_tpl.hpp
index e6949df4a98..4b9f0634385 100644
--- a/src/realm/query_conditions_tpl.hpp
+++ b/src/realm/query_conditions_tpl.hpp
@@ -30,11 +30,9 @@ namespace realm {
 template <class T>
 class QueryStateSum : public QueryStateBase {
 public:
+    using Type = T;
     using ResultType = typename aggregate_operations::Sum<T>::ResultType;
-    explicit QueryStateSum(size_t limit = -1)
-        : QueryStateBase(limit)
-    {
-    }
+    using QueryStateBase::QueryStateBase;
     bool match(size_t, Mixed value) noexcept final
     {
         if (!value.is_null()) {
@@ -58,13 +56,10 @@ class QueryStateSum : public QueryStateBase {
     aggregate_operations::Sum<typename util::RemoveOptional<T>::type> m_state;
 };
 
-template <class R>
-class QueryStateMin : public QueryStateBase {
+template <class R, template <class> class State>
+class QueryStateMinMax : public QueryStateBase {
 public:
-    explicit QueryStateMin(size_t limit = -1)
-        : QueryStateBase(limit)
-    {
-    }
+    using QueryStateBase::QueryStateBase;
     bool match(size_t index, Mixed value) noexcept final
     {
         if (!value.is_null()) {
@@ -75,43 +70,146 @@ class QueryStateMin : public QueryStateBase {
             ++m_match_count;
             m_minmax_key = (m_key_values ? m_key_values->get(index) : 0) + m_key_offset;
         }
-        return (m_limit > m_match_count);
+        return m_limit > m_match_count;
     }
-    R get_min() const
+    Mixed get_result() const
     {
-        return m_state.is_null() ? R{} : m_state.result();
+        return m_state.is_null() ? Mixed() : m_state.result();
     }
 
 private:
-    aggregate_operations::Minimum<typename util::RemoveOptional<R>::type> m_state;
+    State<typename util::RemoveOptional<R>::type> m_state;
+};
+
+template <class R>
+class QueryStateMin : public QueryStateMinMax<R, aggregate_operations::Minimum> {
+public:
+    using QueryStateMinMax<R, aggregate_operations::Minimum>::QueryStateMinMax;
 };
 
 template <class R>
-class QueryStateMax : public QueryStateBase {
+class QueryStateMax : public QueryStateMinMax<R, aggregate_operations::Maximum> {
 public:
-    explicit QueryStateMax(size_t limit = -1)
-        : QueryStateBase(limit)
+    using QueryStateMinMax<R, aggregate_operations::Maximum>::QueryStateMinMax;
+};
+
+template <class Target>
+class AggregateHelper {
+public:
+    static std::optional<Mixed> sum(const Table& table, const Target& target, ColKey col_key)
     {
+        switch (table.get_column_type(col_key)) {
+            case type_Int:
+                if (table.is_nullable(col_key)) {
+                    return sum<std::optional<int64_t>>(target, col_key);
+                }
+                else {
+                    return sum<int64_t>(target, col_key);
+                }
+            case type_Float:
+                return sum<float>(target, col_key);
+            case type_Double:
+                return sum<double>(target, col_key);
+            case type_Decimal:
+                return sum<Decimal128>(target, col_key);
+            case type_Mixed:
+                return sum<Mixed>(target, col_key);
+            default:
+                return std::nullopt;
+        }
     }
-    bool match(size_t index, Mixed value) noexcept final
+
+    static std::optional<Mixed> avg(const Table& table, const Target& target, ColKey col_key, size_t* value_count)
     {
-        if (!value.is_null()) {
-            auto v = value.get<R>();
-            if (!m_state.accumulate(v)) {
-                return true; // no match, continue search
-            }
-            ++m_match_count;
-            m_minmax_key = (m_key_values ? m_key_values->get(index) : 0) + m_key_offset;
+        switch (table.get_column_type(col_key)) {
+            case type_Int:
+                if (table.is_nullable(col_key)) {
+                    return average<std::optional<int64_t>>(target, col_key, value_count);
+                }
+                else {
+                    return average<int64_t>(target, col_key, value_count);
+                }
+            case type_Float:
+                return average<float>(target, col_key, value_count);
+            case type_Double:
+                return average<double>(target, col_key, value_count);
+            case type_Decimal:
+                return average<Decimal128>(target, col_key, value_count);
+            case type_Mixed:
+                return average<Mixed>(target, col_key, value_count);
+            default:
+                return std::nullopt;
         }
-        return (m_limit > m_match_count);
     }
-    R get_max() const
+
+    static std::optional<Mixed> min(const Table& table, const Target& target, ColKey col_key, ObjKey* return_ndx)
+    {
+        return minmax<QueryStateMin>(table, target, col_key, return_ndx);
+    }
+
+    static std::optional<Mixed> max(const Table& table, const Target& target, ColKey col_key, ObjKey* return_ndx)
     {
-        return m_state.is_null() ? R{} : m_state.result();
+        return minmax<QueryStateMax>(table, target, col_key, return_ndx);
     }
 
 private:
-    aggregate_operations::Maximum<typename util::RemoveOptional<R>::type> m_state;
+    template <typename T>
+    static Mixed average(const Target& target, ColKey col_key, size_t* value_count)
+    {
+        QueryStateSum<typename util::RemoveOptional<T>::type> st;
+        target.template aggregate<T>(st, col_key);
+        if (value_count)
+            *value_count = st.result_count();
+        if (st.result_count() == 0)
+            return Mixed();
+
+        using Result = typename aggregate_operations::Average<typename util::RemoveOptional<T>::type>::ResultType;
+        return Result(st.result_sum()) / st.result_count();
+    }
+
+    template <typename T>
+    static Mixed sum(const Target& target, ColKey col_key)
+    {
+        QueryStateSum<typename util::RemoveOptional<T>::type> st;
+        target.template aggregate<T>(st, col_key);
+        return st.result_sum();
+    }
+
+    template <template <typename> typename QueryState>
+    static std::optional<Mixed> minmax(const Table& table, const Target& target, ColKey col_key, ObjKey* return_ndx)
+    {
+        switch (table.get_column_type(col_key)) {
+            case type_Int:
+                if (table.is_nullable(col_key)) {
+                    return minmax<QueryState, std::optional<int64_t>>(target, col_key, return_ndx);
+                }
+                else {
+                    return minmax<QueryState, int64_t>(target, col_key, return_ndx);
+                }
+            case type_Float:
+                return minmax<QueryState, float>(target, col_key, return_ndx);
+            case type_Double:
+                return minmax<QueryState, double>(target, col_key, return_ndx);
+            case type_Decimal:
+                return minmax<QueryState, Decimal128>(target, col_key, return_ndx);
+            case type_Timestamp:
+                return minmax<QueryState, Timestamp>(target, col_key, return_ndx);
+            case type_Mixed:
+                return minmax<QueryState, Mixed>(target, col_key, return_ndx);
+            default:
+                return std::nullopt;
+        }
+    }
+
+    template <template <typename> typename QueryState, typename T>
+    static Mixed minmax(const Target& target, ColKey col_key, ObjKey* return_ndx)
+    {
+        QueryState<typename util::RemoveOptional<T>::type> st;
+        target.template aggregate<T>(st, col_key);
+        if (return_ndx)
+            *return_ndx = ObjKey(st.m_minmax_key);
+        return st.get_result();
+    }
 };
 
 } // namespace realm
diff --git a/src/realm/query_state.hpp b/src/realm/query_state.hpp
index 942f04298a3..6300a291cbb 100644
--- a/src/realm/query_state.hpp
+++ b/src/realm/query_state.hpp
@@ -35,15 +35,11 @@ class Mixed;
 
 class QueryStateBase {
 public:
-    int64_t m_minmax_key; // used only for min/max, to save index of current min/max value
-    uint64_t m_key_offset;
-    const ClusterKeyArray* m_key_values;
-    QueryStateBase(size_t limit)
-        : m_minmax_key(-1)
-        , m_key_offset(0)
-        , m_key_values(nullptr)
-        , m_match_count(0)
-        , m_limit(limit)
+    int64_t m_minmax_key = -1; // used only for min/max, to save index of current min/max value
+    uint64_t m_key_offset = 0;
+    const ClusterKeyArray* m_key_values = nullptr;
+    QueryStateBase(size_t limit = -1)
+        : m_limit(limit)
     {
     }
     virtual ~QueryStateBase() {}
@@ -68,7 +64,7 @@ class QueryStateBase {
     }
 
 protected:
-    size_t m_match_count;
+    size_t m_match_count = 0;
     size_t m_limit;
 
 private:
diff --git a/src/realm/set.hpp b/src/realm/set.hpp
index 93e1cb1b787..bfef7686746 100644
--- a/src/realm/set.hpp
+++ b/src/realm/set.hpp
@@ -347,7 +347,6 @@ class LnkSet final : public ObjCollectionBase<SetBase> {
     std::pair<size_t, bool> erase_any(Mixed value) final;
 
     // Overriding members of ObjList:
-    bool is_obj_valid(size_t) const noexcept final;
     Obj get_object(size_t ndx) const final;
     ObjKey get_key(size_t ndx) const final;
 
@@ -1254,12 +1253,6 @@ inline size_t LnkSet::find_any(Mixed value) const
     return not_found;
 }
 
-inline bool LnkSet::is_obj_valid(size_t) const noexcept
-{
-    // LnkSet cannot contain NULL links.
-    return true;
-}
-
 inline Obj LnkSet::get_object(size_t ndx) const
 {
     ObjKey key = get(ndx);
diff --git a/src/realm/sync/subscriptions.cpp b/src/realm/sync/subscriptions.cpp
index 40a09da3787..6e6bcbf67e2 100644
--- a/src/realm/sync/subscriptions.cpp
+++ b/src/realm/sync/subscriptions.cpp
@@ -627,10 +627,10 @@ SubscriptionSet SubscriptionStore::get_latest() const
     if (sub_sets->is_empty()) {
         return SubscriptionSet(weak_from_this(), *tr, Obj{});
     }
-    auto latest_id = sub_sets->maximum_int(sub_sets->get_primary_key_column());
-    auto latest_obj = sub_sets->get_object_with_primary_key(Mixed{latest_id});
+    auto latest_id = *sub_sets->max(sub_sets->get_primary_key_column());
+    auto latest_obj = sub_sets->get_object_with_primary_key(latest_id);
 
-    return SubscriptionSet(weak_from_this(), *tr, std::move(latest_obj));
+    return SubscriptionSet(weak_from_this(), *tr, latest_obj);
 }
 
 SubscriptionSet SubscriptionStore::get_active() const
@@ -662,7 +662,7 @@ std::pair<int64_t, int64_t> SubscriptionStore::get_active_and_latest_versions()
         return {0, 0};
     }
 
-    auto latest_id = sub_sets->maximum_int(sub_sets->get_primary_key_column());
+    auto latest_id = *sub_sets->max(sub_sets->get_primary_key_column());
     DescriptorOrdering descriptor_ordering;
     descriptor_ordering.append_sort(SortDescriptor{{{sub_sets->get_primary_key_column()}}, {false}});
     descriptor_ordering.append_limit(LimitDescriptor{1});
@@ -671,11 +671,11 @@ std::pair<int64_t, int64_t> SubscriptionStore::get_active_and_latest_versions()
                    .find_all(descriptor_ordering);
 
     if (res.is_empty()) {
-        return {-1, latest_id};
+        return {-1, latest_id.get_int()};
     }
 
     auto active_id = res.get_object(0).get_primary_key();
-    return {active_id.get_int(), latest_id};
+    return {active_id.get_int(), latest_id.get_int()};
 }
 
 util::Optional<SubscriptionStore::PendingSubscription>
@@ -764,8 +764,8 @@ SubscriptionStore::TableSet SubscriptionStore::get_tables_for_latest(const Trans
     if (sub_sets->is_empty()) {
         return {};
     }
-    auto latest_id = sub_sets->maximum_int(sub_sets->get_primary_key_column());
-    auto latest_obj = sub_sets->get_object_with_primary_key(Mixed{latest_id});
+    auto latest_id = *sub_sets->max(sub_sets->get_primary_key_column());
+    auto latest_obj = sub_sets->get_object_with_primary_key(latest_id);
 
     TableSet ret;
     auto subs = latest_obj.get_linklist(m_sub_set_subscriptions);
@@ -819,7 +819,7 @@ MutableSubscriptionSet SubscriptionStore::make_mutable_copy(const SubscriptionSe
     auto new_tr = m_db->start_write();
 
     auto sub_sets = new_tr->get_table(m_sub_set_table);
-    auto new_pk = sub_sets->maximum_int(sub_sets->get_primary_key_column()) + 1;
+    auto new_pk = sub_sets->max(sub_sets->get_primary_key_column())->get_int() + 1;
 
     MutableSubscriptionSet new_set_obj(weak_from_this(), std::move(new_tr),
                                        sub_sets->create_object_with_primary_key(Mixed{new_pk}));
diff --git a/src/realm/table.cpp b/src/realm/table.cpp
index f337ac17a3f..9fa330d4d92 100644
--- a/src/realm/table.cpp
+++ b/src/realm/table.cpp
@@ -16,33 +16,34 @@
  *
  **************************************************************************/
 
-#include <stdexcept>
-
-#ifdef REALM_DEBUG
-#include <iostream>
-#include <iomanip>
-#endif
-
-#include <realm/util/features.h>
-#include <realm/util/miscellaneous.hpp>
-#include <realm/util/serializer.hpp>
-#include <realm/impl/destroy_guard.hpp>
-#include <realm/exceptions.hpp>
 #include <realm/table.hpp>
+
 #include <realm/alloc_slab.hpp>
-#include <realm/index_string.hpp>
-#include <realm/db.hpp>
-#include <realm/replication.hpp>
-#include <realm/table_view.hpp>
-#include <realm/query_engine.hpp>
-#include <realm/array_bool.hpp>
 #include <realm/array_binary.hpp>
-#include <realm/array_string.hpp>
-#include <realm/array_timestamp.hpp>
+#include <realm/array_bool.hpp>
 #include <realm/array_decimal128.hpp>
 #include <realm/array_fixed_bytes.hpp>
-#include <realm/table_tpl.hpp>
+#include <realm/array_string.hpp>
+#include <realm/array_timestamp.hpp>
+#include <realm/db.hpp>
 #include <realm/dictionary.hpp>
+#include <realm/exceptions.hpp>
+#include <realm/impl/destroy_guard.hpp>
+#include <realm/index_string.hpp>
+#include <realm/query_conditions_tpl.hpp>
+#include <realm/query_engine.hpp>
+#include <realm/replication.hpp>
+#include <realm/table_view.hpp>
+#include <realm/util/features.h>
+#include <realm/util/miscellaneous.hpp>
+#include <realm/util/serializer.hpp>
+
+#include <stdexcept>
+
+#ifdef REALM_DEBUG
+#include <iostream>
+#include <iomanip>
+#endif
 
 /// \page AccessorConsistencyLevels
 ///
@@ -2156,244 +2157,59 @@ size_t Table::count_string(ColKey col_key, StringData value) const
     return where().equal(col_key, value).count();
 }
 
-// sum ----------------------------------------------
-
-
-int64_t Table::sum_int(ColKey col_key) const
-{
-    QueryStateSum<int64_t> st;
-    if (is_nullable(col_key)) {
-        aggregate<util::Optional<int64_t>>(st, col_key);
-    }
-    else {
-        aggregate<int64_t>(st, col_key);
-    }
-    return st.result_sum();
-}
-double Table::sum_float(ColKey col_key) const
-{
-    QueryStateSum<float> st;
-    aggregate<float>(st, col_key);
-    return st.result_sum();
-}
-double Table::sum_double(ColKey col_key) const
-{
-    QueryStateSum<double> st;
-    aggregate<double>(st, col_key);
-    return st.result_sum();
-}
-Decimal128 Table::sum_decimal(ColKey col_key) const
-{
-    QueryStateSum<Decimal128> st;
-    aggregate<Decimal128>(st, col_key);
-    return st.result_sum();
-}
-Decimal128 Table::sum_mixed(ColKey col_key) const
-{
-    QueryStateSum<Mixed> st;
-    aggregate<Mixed>(st, col_key);
-    return st.result_sum();
-}
-
-// average ----------------------------------------------
-
-double Table::average_int(ColKey col_key, size_t* value_count) const
-{
-    if (is_nullable(col_key)) {
-        return average<util::Optional<int64_t>>(col_key, value_count);
-    }
-    return average<int64_t>(col_key, value_count);
-}
-double Table::average_float(ColKey col_key, size_t* value_count) const
-{
-    return average<float>(col_key, value_count);
-}
-double Table::average_double(ColKey col_key, size_t* value_count) const
-{
-    return average<double>(col_key, value_count);
-}
-Decimal128 Table::average_decimal(ColKey col_key, size_t* value_count) const
+template <typename T>
+void Table::aggregate(QueryStateBase& st, ColKey column_key) const
 {
-    QueryStateSum<Decimal128> st;
-    aggregate<Decimal128>(st, col_key);
-    auto sum = st.result_sum();
-    Decimal128 avg(0);
-    size_t items_counted = st.result_count();
-    if (items_counted != 0)
-        avg = sum / items_counted;
-    if (value_count)
-        *value_count = items_counted;
-    return avg;
-}
-
-Decimal128 Table::average_mixed(ColKey col_key, size_t* value_count) const
-{
-    QueryStateSum<Mixed> st;
-    aggregate<Mixed>(st, col_key);
-    auto sum = st.result_sum();
-    Decimal128 avg(0);
-    size_t items_counted = st.result_count();
-    if (items_counted != 0)
-        avg = sum / items_counted;
-    if (value_count)
-        *value_count = items_counted;
-    return avg;
-}
-
-// minimum ----------------------------------------------
-
-#define USE_COLUMN_AGGREGATE 1
-
-int64_t Table::minimum_int(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<int64_t> st;
-    if (is_nullable(col_key)) {
-        aggregate<util::Optional<int64_t>>(st, col_key);
-    }
-    else {
-        aggregate<int64_t>(st, col_key);
-    }
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
-
-float Table::minimum_float(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<float> st;
-    aggregate<float>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
-
-double Table::minimum_double(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<double> st;
-    aggregate<double>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
-
-Decimal128 Table::minimum_decimal(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<Decimal128> st;
-    aggregate<Decimal128>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
-
-Timestamp Table::minimum_timestamp(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<Timestamp> st;
-    aggregate<Timestamp>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
-
-Mixed Table::minimum_mixed(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMin<Mixed> st;
-    aggregate<Mixed>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_min();
-}
+    using LeafType = typename ColumnTypeTraits<T>::cluster_leaf_type;
+    LeafType leaf(get_alloc());
 
+    auto f = [&leaf, column_key, &st](const Cluster* cluster) {
+        // direct aggregate on the leaf
+        cluster->init_leaf(column_key, &leaf);
+        st.m_key_offset = cluster->get_offset();
+        st.m_key_values = cluster->get_key_array();
 
-// maximum ----------------------------------------------
+        bool cont = true;
+        size_t sz = leaf.size();
+        for (size_t local_index = 0; cont && local_index < sz; local_index++) {
+            auto v = leaf.get(local_index);
+            cont = st.match(local_index, v);
+        }
+        return IteratorControl::AdvanceToNext;
+    };
 
-int64_t Table::maximum_int(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMax<int64_t> st;
-    if (is_nullable(col_key)) {
-        aggregate<util::Optional<int64_t>>(st, col_key);
-    }
-    else {
-        aggregate<int64_t>(st, col_key);
-    }
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_max();
+    traverse_clusters(f);
 }
 
-float Table::maximum_float(ColKey col_key, ObjKey* return_ndx) const
-{
-    QueryStateMax<float> st;
-    aggregate<float>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_max();
-}
+// This template is also used by the query engine
+template void Table::aggregate<int64_t>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<std::optional<int64_t>>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<float>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<double>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<Decimal128>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<Mixed>(QueryStateBase&, ColKey) const;
+template void Table::aggregate<Timestamp>(QueryStateBase&, ColKey) const;
 
-double Table::maximum_double(ColKey col_key, ObjKey* return_ndx) const
+std::optional<Mixed> Table::sum(ColKey col_key) const
 {
-    QueryStateMax<double> st;
-    aggregate<double>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_max();
+    return AggregateHelper<Table>::sum(*this, *this, col_key);
 }
 
-Decimal128 Table::maximum_decimal(ColKey col_key, ObjKey* return_ndx) const
+std::optional<Mixed> Table::avg(ColKey col_key, size_t* value_count) const
 {
-    ArrayDecimal128 leaf(get_alloc());
-    Decimal128 max("-Inf");
-    ObjKey ret_key;
-    auto f = [&max, &ret_key, &leaf, col_key](const Cluster* cluster) {
-        // direct aggregate on the leaf
-        cluster->init_leaf(col_key, &leaf);
-        auto sz = leaf.size();
-        for (size_t i = 0; i < sz; i++) {
-            auto val = leaf.get(i);
-            if (!val.is_null() && val > max) {
-                max = val;
-                ret_key = cluster->get_real_key(i);
-            }
-        }
-        return IteratorControl::AdvanceToNext;
-    };
-
-    traverse_clusters(f);
-    if (return_ndx) {
-        *return_ndx = ObjKey(ret_key);
-    }
-    return max;
+    return AggregateHelper<Table>::avg(*this, *this, col_key, value_count);
 }
 
-Timestamp Table::maximum_timestamp(ColKey col_key, ObjKey* return_ndx) const
+std::optional<Mixed> Table::min(ColKey col_key, ObjKey* return_ndx) const
 {
-    QueryStateMax<Timestamp> st;
-    aggregate<Timestamp>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_max();
+    return AggregateHelper<Table>::min(*this, *this, col_key, return_ndx);
 }
 
-Mixed Table::maximum_mixed(ColKey col_key, ObjKey* return_ndx) const
+std::optional<Mixed> Table::max(ColKey col_key, ObjKey* return_ndx) const
 {
-    QueryStateMax<Mixed> st;
-    aggregate<Mixed>(st, col_key);
-    if (return_ndx) {
-        *return_ndx = ObjKey(st.m_minmax_key);
-    }
-    return st.get_max();
+    return AggregateHelper<Table>::max(*this, *this, col_key, return_ndx);
 }
 
-
 template <class T>
 ObjKey Table::find_first(ColKey col_key, T value) const
 {
diff --git a/src/realm/table.hpp b/src/realm/table.hpp
index 01f436e1f8b..91e64e53b15 100644
--- a/src/realm/table.hpp
+++ b/src/realm/table.hpp
@@ -381,28 +381,13 @@ class Table {
     size_t count_double(ColKey col_key, double value) const;
     size_t count_decimal(ColKey col_key, Decimal128 value) const;
 
-    int64_t sum_int(ColKey col_key) const;
-    double sum_float(ColKey col_key) const;
-    double sum_double(ColKey col_key) const;
-    Decimal128 sum_decimal(ColKey col_key) const;
-    Decimal128 sum_mixed(ColKey col_key) const;
-    int64_t maximum_int(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    float maximum_float(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    double maximum_double(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Decimal128 maximum_decimal(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Mixed maximum_mixed(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Timestamp maximum_timestamp(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    int64_t minimum_int(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    float minimum_float(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    double minimum_double(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Decimal128 minimum_decimal(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Mixed minimum_mixed(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    Timestamp minimum_timestamp(ColKey col_key, ObjKey* return_ndx = nullptr) const;
-    double average_int(ColKey col_key, size_t* value_count = nullptr) const;
-    double average_float(ColKey col_key, size_t* value_count = nullptr) const;
-    double average_double(ColKey col_key, size_t* value_count = nullptr) const;
-    Decimal128 average_decimal(ColKey col_key, size_t* value_count = nullptr) const;
-    Decimal128 average_mixed(ColKey col_key, size_t* value_count = nullptr) const;
+    // Aggregates return nullopt if the operation is not supported on the given column
+    // Everything but `sum` returns `some(null)` if there are no non-null values
+    // Sum returns `some(0)` if there are no non-null values.
+    std::optional<Mixed> sum(ColKey col_key) const;
+    std::optional<Mixed> min(ColKey col_key, ObjKey* = nullptr) const;
+    std::optional<Mixed> max(ColKey col_key, ObjKey* = nullptr) const;
+    std::optional<Mixed> avg(ColKey col_key, size_t* value_count = nullptr) const;
 
     // Will return pointer to search index accessor. Will return nullptr if no index
     StringIndex* get_search_index(ColKey col) const noexcept
@@ -827,10 +812,9 @@ class Table {
     void flush_for_commit();
 
     bool is_cross_table_link_target() const noexcept;
+
     template <typename T>
     void aggregate(QueryStateBase& st, ColKey col_key) const;
-    template <typename T>
-    double average(ColKey col_key, size_t* resultcount) const;
 
     std::vector<ColKey> m_leaf_ndx2colkey;
     std::vector<ColKey::Idx> m_spec_ndx2leaf_ndx;
@@ -858,13 +842,11 @@ class Table {
 
     enum { s_collision_map_lo = 0, s_collision_map_hi = 1, s_collision_map_local_id = 2, s_collision_map_num_slots };
 
-    friend class SubtableNode;
     friend class _impl::TableFriend;
     friend class Query;
     friend class metrics::QueryInfo;
     template <class>
     friend class SimpleQuerySupport;
-    friend class LangBindHelper;
     friend class TableView;
     template <class T>
     friend class Columns;
@@ -883,6 +865,8 @@ class Table {
     friend class LnkLst;
     friend class Dictionary;
     friend class IncludeDescriptor;
+    template <class T>
+    friend class AggregateHelper;
 };
 
 inline std::ostream& operator<<(std::ostream& o, Table::Type table_type)
diff --git a/src/realm/table_ref.hpp b/src/realm/table_ref.hpp
index f454792c906..f9d433a4096 100644
--- a/src/realm/table_ref.hpp
+++ b/src/realm/table_ref.hpp
@@ -29,8 +29,8 @@ class TableRef;
 
 class ConstTableRef {
 public:
-    ConstTableRef() noexcept {}
-    ConstTableRef(std::nullptr_t) noexcept {}
+    constexpr ConstTableRef() noexcept = default;
+    constexpr ConstTableRef(std::nullptr_t) noexcept {}
     ConstTableRef(const TableRef& other) noexcept;
 
     const Table* operator->() const;
@@ -91,14 +91,8 @@ class ConstTableRef {
 
 class TableRef : public ConstTableRef {
 public:
-    TableRef() noexcept
-        : ConstTableRef()
-    {
-    }
-    TableRef(std::nullptr_t) noexcept
-        : ConstTableRef()
-    {
-    }
+    constexpr TableRef() noexcept = default;
+    constexpr TableRef(std::nullptr_t) noexcept {}
 
     Table* operator->() const;
     Table& operator*() const;
diff --git a/src/realm/table_tpl.hpp b/src/realm/table_tpl.hpp
deleted file mode 100644
index ffeafab8022..00000000000
--- a/src/realm/table_tpl.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*************************************************************************
- *
- * Copyright 2016 Realm Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- **************************************************************************/
-
-#ifndef REALM_TABLE_TPL_HPP
-#define REALM_TABLE_TPL_HPP
-
-#include <realm/table.hpp>
-#include <realm/query_conditions_tpl.hpp>
-
-namespace realm {
-
-template <typename T>
-void Table::aggregate(QueryStateBase& st, ColKey column_key) const
-{
-    using LeafType = typename ColumnTypeTraits<T>::cluster_leaf_type;
-    LeafType leaf(get_alloc());
-
-    auto f = [&leaf, column_key, &st](const Cluster* cluster) {
-        // direct aggregate on the leaf
-        cluster->init_leaf(column_key, &leaf);
-        st.m_key_offset = cluster->get_offset();
-        st.m_key_values = cluster->get_key_array();
-
-        bool cont = true;
-        size_t sz = leaf.size();
-        for (size_t local_index = 0; cont && local_index < sz; local_index++) {
-            auto v = leaf.get(local_index);
-            cont = st.match(local_index, v);
-        }
-        return IteratorControl::AdvanceToNext;
-    };
-
-    traverse_clusters(f);
-}
-
-template <typename T>
-double Table::average(ColKey col_key, size_t* resultcount) const
-{
-    QueryStateSum<typename util::RemoveOptional<T>::type> st;
-    aggregate<T>(st, col_key);
-    auto sum = st.result_sum();
-    double avg = 0;
-    size_t items_counted = st.result_count();
-    if (items_counted != 0)
-        avg = double(sum) / items_counted;
-    if (resultcount)
-        *resultcount = items_counted;
-    return avg;
-}
-}
-
-
-#endif /* REALM_TABLE_TPL_HPP */
diff --git a/src/realm/table_view.cpp b/src/realm/table_view.cpp
index 2a1a74697da..06dead80529 100644
--- a/src/realm/table_view.cpp
+++ b/src/realm/table_view.cpp
@@ -57,7 +57,8 @@ TableView::TableView(TableView& src, Transaction* tr, PayloadPolicy policy_mode)
     : m_source_column_key(src.m_source_column_key)
 {
     bool was_in_sync = src.is_in_sync();
-    m_query = Query(src.m_query, tr, policy_mode);
+    if (src.m_query)
+        m_query = Query(*src.m_query, tr, policy_mode);
     m_table = tr->import_copy_of(src.m_table);
 
     if (policy_mode == PayloadPolicy::Stay)
@@ -122,46 +123,35 @@ struct Aggregator<T, act_Max> {
     using AggType = typename aggregate_operations::Maximum<typename util::RemoveOptional<T>::type>;
 };
 
-template <Action action, typename T, typename R>
-R TableView::aggregate(ColKey column_key, size_t* result_count, ObjKey* return_key) const
+template <Action action, typename T>
+Mixed TableView::aggregate(ColKey column_key, size_t* result_count, ObjKey* return_key) const
 {
-    size_t non_nulls = 0;
-
-    if (return_key)
-        *return_key = null_key;
-    if (result_count)
-        *result_count = 0;
-
-    REALM_ASSERT(action == act_Sum || action == act_Max || action == act_Min || action == act_Average);
+    static_assert(action == act_Sum || action == act_Max || action == act_Min || action == act_Average);
     REALM_ASSERT(m_table->valid_column(column_key));
 
-    if ((m_key_values.size()) == 0) {
-        return {};
-    }
-
+    size_t non_nulls = 0;
     typename Aggregator<T, action>::AggType agg;
     ObjKey last_accumulated_key = null_key;
     for (size_t tv_index = 0; tv_index < m_key_values.size(); ++tv_index) {
-
         ObjKey key(get_key(tv_index));
 
         // skip detached references:
         if (key == realm::null_key)
             continue;
 
+        const Obj obj = m_table->try_get_object(key);
         // aggregation must be robust in the face of stale keys:
-        if (!m_table->is_valid(key))
+        if (!obj.is_valid())
             continue;
 
-        const Obj obj = m_table->get_object(key);
-        auto v = obj.get<T>(column_key);
+        if (obj.is_null(column_key))
+            continue;
 
-        if (!obj.is_null(column_key)) {
-            if (agg.accumulate(v)) {
-                ++non_nulls;
-                if constexpr (action == act_Min || action == act_Max) {
-                    last_accumulated_key = key;
-                }
+        auto v = obj.get<T>(column_key);
+        if (agg.accumulate(v)) {
+            ++non_nulls;
+            if constexpr (action == act_Min || action == act_Max) {
+                last_accumulated_key = key;
             }
         }
     }
@@ -169,7 +159,6 @@ R TableView::aggregate(ColKey column_key, size_t* result_count, ObjKey* return_k
     if (result_count)
         *result_count = non_nulls;
 
-    R res{};
     if constexpr (action == act_Max || action == act_Min) {
         if (return_key) {
             *return_key = last_accumulated_key;
@@ -180,10 +169,15 @@ R TableView::aggregate(ColKey column_key, size_t* result_count, ObjKey* return_k
     }
 
     if (!agg.is_null()) {
-        res = agg.result();
+        return agg.result();
     }
-
-    return res;
+    if (action == act_Sum) {
+        if (std::is_same_v<T, Mixed>) {
+            return Decimal128{0};
+        }
+        return T{};
+    }
+    return Mixed();
 }
 
 template <typename T>
@@ -197,211 +191,103 @@ size_t TableView::aggregate_count(ColKey column_key, T count_target) const
 
     size_t cnt = 0;
     for (size_t tv_index = 0; tv_index < m_key_values.size(); ++tv_index) {
-
         ObjKey key(get_key(tv_index));
 
         // skip detached references:
         if (key == realm::null_key)
             continue;
 
-        try {
-            const Obj obj = m_table->get_object(key);
-            auto v = obj.get<T>(column_key);
+        const Obj obj = m_table->try_get_object(key);
+        if (!obj.is_valid())
+            continue;
 
-            if (v == count_target) {
-                cnt++;
-            }
-        }
-        catch (const realm::KeyNotFound&) {
+        auto v = obj.get<T>(column_key);
+        if (v == count_target) {
+            cnt++;
         }
     }
 
     return cnt;
 }
 
-// Min, Max and Count on Timestamp cannot utilize existing aggregate() methods, becuase these assume
-// numeric types that support arithmetic (+, /, etc).
-template <class C>
-Timestamp TableView::minmax_timestamp(ColKey column_key, ObjKey* return_key) const
-{
-    Timestamp best_value;
-    ObjKey best_key;
-    for_each([&best_key, &best_value, column_key](const Obj& obj) {
-        C compare;
-        auto ts = obj.get<Timestamp>(column_key);
-        // Because realm::Greater(non-null, null) == false, we need to pick the initial 'best' manually when we see
-        // the first non-null entry
-        if ((best_key == null_key && !ts.is_null()) || compare(ts, best_value, ts.is_null(), best_value.is_null())) {
-            best_value = ts;
-            best_key = obj.get_key();
-        }
-        return IteratorControl::AdvanceToNext;
-    });
-    if (return_key)
-        *return_key = best_key;
-
-    return best_value;
-}
-
-// sum
-int64_t TableView::sum_int(ColKey column_key) const
-{
-    if (m_table->is_nullable(column_key))
-        return aggregate<act_Sum, util::Optional<int64_t>, int64_t>(column_key, 0);
-    else {
-        return aggregate<act_Sum, int64_t, int64_t>(column_key, 0);
-    }
-}
-double TableView::sum_float(ColKey column_key) const
-{
-    return aggregate<act_Sum, float, double>(column_key);
-}
-double TableView::sum_double(ColKey column_key) const
-{
-    return aggregate<act_Sum, double, double>(column_key);
-}
-
-Decimal128 TableView::sum_decimal(ColKey column_key) const
-{
-    return aggregate<act_Sum, Decimal128, Decimal128>(column_key);
-}
-
-Decimal128 TableView::sum_mixed(ColKey column_key) const
-{
-    return aggregate<act_Sum, Mixed, Decimal128>(column_key);
-}
-
-// Maximum
-int64_t TableView::maximum_int(ColKey column_key, ObjKey* return_key) const
+// Count
+size_t TableView::count_int(ColKey column_key, int64_t target) const
 {
     if (m_table->is_nullable(column_key))
-        return aggregate<act_Max, util::Optional<int64_t>, int64_t>(column_key, nullptr, return_key);
+        return aggregate_count<util::Optional<int64_t>>(column_key, target);
     else
-        return aggregate<act_Max, int64_t, int64_t>(column_key, nullptr, return_key);
+        return aggregate_count<int64_t>(column_key, target);
 }
-float TableView::maximum_float(ColKey column_key, ObjKey* return_key) const
+size_t TableView::count_float(ColKey column_key, float target) const
 {
-    return aggregate<act_Max, float, float>(column_key, nullptr, return_key);
+    return aggregate_count<float>(column_key, target);
 }
-double TableView::maximum_double(ColKey column_key, ObjKey* return_key) const
+size_t TableView::count_double(ColKey column_key, double target) const
 {
-    return aggregate<act_Max, double, double>(column_key, nullptr, return_key);
+    return aggregate_count<double>(column_key, target);
 }
-Timestamp TableView::maximum_timestamp(ColKey column_key, ObjKey* return_key) const
+size_t TableView::count_timestamp(ColKey column_key, Timestamp target) const
 {
-    return minmax_timestamp<realm::Greater>(column_key, return_key);
+    return aggregate_count<Timestamp>(column_key, target);
 }
-Decimal128 TableView::maximum_decimal(ColKey column_key, ObjKey* return_key) const
+size_t TableView::count_decimal(ColKey column_key, Decimal128 target) const
 {
-    return aggregate<act_Max, Decimal128, Decimal128>(column_key, nullptr, return_key);
+    return aggregate_count<Decimal128>(column_key, target);
 }
-Mixed TableView::maximum_mixed(ColKey column_key, ObjKey* return_key) const
+size_t TableView::count_mixed(ColKey column_key, Mixed target) const
 {
-    return aggregate<act_Max, Mixed, Mixed>(column_key, nullptr, return_key);
+    return aggregate_count<Mixed>(column_key, target);
 }
 
-// Minimum
-int64_t TableView::minimum_int(ColKey column_key, ObjKey* return_key) const
-{
-    if (m_table->is_nullable(column_key))
-        return aggregate<act_Min, util::Optional<int64_t>, int64_t>(column_key, nullptr, return_key);
-    else
-        return aggregate<act_Min, int64_t, int64_t>(column_key, nullptr, return_key);
-}
-float TableView::minimum_float(ColKey column_key, ObjKey* return_key) const
-{
-    return aggregate<act_Min, float, float>(column_key, nullptr, return_key);
-}
-double TableView::minimum_double(ColKey column_key, ObjKey* return_key) const
-{
-    return aggregate<act_Min, double, double>(column_key, nullptr, return_key);
-}
-Timestamp TableView::minimum_timestamp(ColKey column_key, ObjKey* return_key) const
-{
-    return minmax_timestamp<realm::Less>(column_key, return_key);
-}
-Decimal128 TableView::minimum_decimal(ColKey column_key, ObjKey* return_key) const
-{
-    return aggregate<act_Min, Decimal128, Decimal128>(column_key, nullptr, return_key);
-}
-Mixed TableView::minimum_mixed(ColKey column_key, ObjKey* return_key) const
+template <Action action>
+std::optional<Mixed> TableView::aggregate(ColKey column_key, size_t* count, ObjKey* return_key) const
 {
-    return aggregate<act_Min, Mixed, Mixed>(column_key, nullptr, return_key);
-}
+    static_assert(action == act_Sum || action == act_Max || action == act_Min || action == act_Average);
 
-// Average. The number of values used to compute the result is written to `value_count` by callee
-double TableView::average_int(ColKey column_key, size_t* value_count) const
-{
-    if (m_table->is_nullable(column_key))
-        return aggregate<act_Average, util::Optional<int64_t>, double>(column_key, value_count);
-    else
-        return aggregate<act_Average, int64_t, double>(column_key, value_count);
-}
-double TableView::average_float(ColKey column_key, size_t* value_count) const
-{
-    return aggregate<act_Average, float, double>(column_key, value_count);
-}
-double TableView::average_double(ColKey column_key, size_t* value_count) const
-{
-    return aggregate<act_Average, double, double>(column_key, value_count);
-}
-Decimal128 TableView::average_decimal(ColKey column_key, size_t* value_count) const
-{
-    return aggregate<act_Average, Decimal128, Decimal128>(column_key, value_count);
-}
-Decimal128 TableView::average_mixed(ColKey column_key, size_t* value_count) const
-{
-    return aggregate<act_Average, Mixed, Decimal128>(column_key, value_count);
+    switch (column_key.get_type()) {
+        case col_type_Int:
+            if (m_table->is_nullable(column_key))
+                return aggregate<action, util::Optional<int64_t>>(column_key, count, return_key);
+            return aggregate<action, int64_t>(column_key, count, return_key);
+        case col_type_Float:
+            return aggregate<action, float>(column_key, count, return_key);
+        case col_type_Double:
+            return aggregate<action, double>(column_key, count, return_key);
+        case col_type_Timestamp:
+            if constexpr (action == act_Min || action == act_Max) {
+                return aggregate<action, Timestamp>(column_key, count, return_key);
+            }
+            break;
+        case col_type_Decimal:
+            return aggregate<action, Decimal128>(column_key, count, return_key);
+        case col_type_Mixed:
+            return aggregate<action, Mixed>(column_key, count, return_key);
+        default:
+            break;
+    }
+    return util::none;
 }
 
-// Count
-size_t TableView::count_int(ColKey column_key, int64_t target) const
-{
-    if (m_table->is_nullable(column_key))
-        return aggregate_count<util::Optional<int64_t>>(column_key, target);
-    else
-        return aggregate_count<int64_t>(column_key, target);
-}
-size_t TableView::count_float(ColKey column_key, float target) const
-{
-    return aggregate_count<float>(column_key, target);
-}
-size_t TableView::count_double(ColKey column_key, double target) const
+util::Optional<Mixed> TableView::min(ColKey column_key, ObjKey* return_key) const
 {
-    return aggregate_count<double>(column_key, target);
+    return aggregate<act_Min>(column_key, nullptr, return_key);
 }
 
-size_t TableView::count_timestamp(ColKey column_key, Timestamp target) const
+util::Optional<Mixed> TableView::max(ColKey column_key, ObjKey* return_key) const
 {
-    size_t count = 0;
-    for (size_t t = 0; t < size(); t++) {
-        try {
-            ObjKey key = get_key(t);
-            const Obj obj = m_table->get_object(key);
-            auto ts = obj.get<Timestamp>(column_key);
-            realm::Equal e;
-            if (e(ts, target, ts.is_null(), target.is_null())) {
-                count++;
-            }
-        }
-        catch (const KeyNotFound&) {
-            // Just skip objects that might have been deleted
-        }
-    }
-    return count;
+    return aggregate<act_Max>(column_key, nullptr, return_key);
 }
 
-size_t TableView::count_decimal(ColKey column_key, Decimal128 target) const
+util::Optional<Mixed> TableView::sum(ColKey column_key) const
 {
-    return aggregate_count<Decimal128>(column_key, target);
+    return aggregate<act_Sum>(column_key, nullptr, nullptr);
 }
 
-size_t TableView::count_mixed(ColKey column_key, Mixed target) const
+util::Optional<Mixed> TableView::avg(ColKey column_key, size_t* value_count) const
 {
-    return aggregate_count<Mixed>(column_key, target);
+    return aggregate<act_Average>(column_key, value_count, nullptr);
 }
 
-
 void TableView::to_json(std::ostream& out, size_t link_depth, const std::map<std::string, std::string>& renames,
                         JSONOutputMode mode) const
 {
@@ -434,8 +320,8 @@ bool TableView::depends_on_deleted_object() const
     if (m_source_column_key && !m_linked_obj.is_valid()) {
         return true;
     }
-    else if (m_query.m_source_table_view) {
-        return m_query.m_source_table_view->depends_on_deleted_object();
+    else if (m_query && m_query->m_source_table_view) {
+        return m_query->m_source_table_view->depends_on_deleted_object();
     }
     return false;
 }
@@ -448,8 +334,8 @@ void TableView::get_dependencies(TableVersions& ret) const
             ret.emplace_back(linked_table->get_key(), linked_table->get_content_version());
         }
     }
-    else if (m_query.m_table) {
-        m_query.get_outside_versions(ret);
+    else if (m_query) {
+        m_query->get_outside_versions(ret);
     }
     else {
         // This TableView was created by Table::get_distinct_view() or get_sorted_view() on collections
@@ -477,8 +363,9 @@ void TableView::sync_if_needed() const
 
 void TableView::update_query(const Query& q)
 {
-    REALM_ASSERT(m_query.m_table);
-    REALM_ASSERT(m_query.m_table == q.m_table);
+    REALM_ASSERT(m_query);
+    REALM_ASSERT(m_query->m_table);
+    REALM_ASSERT(m_query->m_table == q.m_table);
 
     m_query = q;
     do_sync();
@@ -587,7 +474,8 @@ void TableView::do_sync()
     }
     // FIXME: Unimplemented for link to a column
     else {
-        m_query.m_table.check();
+        REALM_ASSERT(m_query);
+        m_query->m_table.check();
 
         // valid query, so clear earlier results and reexecute it.
         if (m_key_values.is_attached())
@@ -595,9 +483,9 @@ void TableView::do_sync()
         else
             m_key_values.create();
 
-        if (m_query.m_view)
-            m_query.m_view->sync_if_needed();
-        m_query.do_find_all(*const_cast<TableView*>(this), m_limit);
+        if (m_query->m_view)
+            m_query->m_view->sync_if_needed();
+        m_query->do_find_all(*const_cast<TableView*>(this), m_limit);
     }
 
     do_sort(m_descriptor_ordering);
@@ -664,11 +552,11 @@ bool TableView::is_in_table_order() const
     else if (m_source_column_key) {
         return false;
     }
-    else if (!m_query.m_table) {
+    else if (!m_query) {
         return false;
     }
     else {
-        m_query.m_table.check();
-        return m_query.produces_results_in_table_order() && !m_descriptor_ordering.will_apply_sort();
+        m_query->m_table.check();
+        return m_query->produces_results_in_table_order() && !m_descriptor_ordering.will_apply_sort();
     }
 }
diff --git a/src/realm/table_view.hpp b/src/realm/table_view.hpp
index af720f67d5c..02eb796c710 100644
--- a/src/realm/table_view.hpp
+++ b/src/realm/table_view.hpp
@@ -152,7 +152,6 @@ class TableView : public ObjList {
     /// Construct null view (no memory allocated).
     TableView() {}
 
-
     /// Construct empty view, ready for addition of row indices.
     explicit TableView(ConstTableRef parent);
     TableView(const Query& query, size_t limit);
@@ -201,20 +200,12 @@ class TableView : public ObjList {
         return m_key_values.get(ndx);
     }
 
-    bool is_obj_valid(size_t ndx) const noexcept final
+    bool is_obj_valid(size_t ndx) const noexcept
     {
         return m_table->is_valid(get_key(ndx));
     }
 
-    Obj get_object(size_t ndx) const final
-    {
-        REALM_ASSERT(ndx < size());
-        ObjKey key(m_key_values.get(ndx));
-        REALM_ASSERT(key);
-        return m_table->get_object(key);
-    }
-
-    Obj try_get_object(size_t ndx) const noexcept override
+    Obj get_object(size_t ndx) const noexcept final
     {
         REALM_ASSERT(ndx < size());
         ObjKey key(m_key_values.get(ndx));
@@ -224,7 +215,7 @@ class TableView : public ObjList {
     // Get the query used to create this TableView
     // The query will have a null source table if this tv was not created from
     // a query
-    const Query& get_query() const noexcept
+    const std::optional<Query>& get_query() const noexcept
     {
         return m_query;
     }
@@ -254,45 +245,34 @@ class TableView : public ObjList {
         std::unique_ptr<TableView> retval(new TableView(*this, tr, mode));
         return retval;
     }
-    template <Action action, typename T, typename R>
-    R aggregate(ColKey column_key, size_t* result_count = nullptr, ObjKey* return_key = nullptr) const;
+    template <Action action, typename T>
+    Mixed aggregate(ColKey column_key, size_t* result_count = nullptr, ObjKey* return_key = nullptr) const;
     template <typename T>
     size_t aggregate_count(ColKey column_key, T count_target) const;
 
-    int64_t sum_int(ColKey column_key) const;
-    int64_t maximum_int(ColKey column_key, ObjKey* return_key = nullptr) const;
-    int64_t minimum_int(ColKey column_key, ObjKey* return_key = nullptr) const;
-    double average_int(ColKey column_key, size_t* value_count = nullptr) const;
     size_t count_int(ColKey column_key, int64_t target) const;
-
-    double sum_float(ColKey column_key) const;
-    float maximum_float(ColKey column_key, ObjKey* return_key = nullptr) const;
-    float minimum_float(ColKey column_key, ObjKey* return_key = nullptr) const;
-    double average_float(ColKey column_key, size_t* value_count = nullptr) const;
     size_t count_float(ColKey column_key, float target) const;
-
-    double sum_double(ColKey column_key) const;
-    double maximum_double(ColKey column_key, ObjKey* return_key = nullptr) const;
-    double minimum_double(ColKey column_key, ObjKey* return_key = nullptr) const;
-    double average_double(ColKey column_key, size_t* value_count = nullptr) const;
     size_t count_double(ColKey column_key, double target) const;
-
-    Timestamp minimum_timestamp(ColKey column_key, ObjKey* return_key = nullptr) const;
-    Timestamp maximum_timestamp(ColKey column_key, ObjKey* return_key = nullptr) const;
     size_t count_timestamp(ColKey column_key, Timestamp target) const;
-
-    Decimal128 sum_decimal(ColKey column_key) const;
-    Decimal128 maximum_decimal(ColKey column_key, ObjKey* return_key = nullptr) const;
-    Decimal128 minimum_decimal(ColKey column_key, ObjKey* return_key = nullptr) const;
-    Decimal128 average_decimal(ColKey column_key, size_t* value_count = nullptr) const;
     size_t count_decimal(ColKey column_key, Decimal128 target) const;
-
-    Decimal128 sum_mixed(ColKey column_key) const;
-    Mixed maximum_mixed(ColKey column_key, ObjKey* return_key = nullptr) const;
-    Mixed minimum_mixed(ColKey column_key, ObjKey* return_key = nullptr) const;
-    Decimal128 average_mixed(ColKey column_key, size_t* value_count = nullptr) const;
     size_t count_mixed(ColKey column_key, Mixed target) const;
 
+    /// Get the min element, according to whatever comparison function is
+    /// meaningful for the collection, or none if min is not supported for this type.
+    util::Optional<Mixed> min(ColKey column_key, ObjKey* return_key = nullptr) const;
+
+    /// Get the max element, according to whatever comparison function is
+    /// meaningful for the collection, or none if max is not supported for this type.
+    util::Optional<Mixed> max(ColKey column_key, ObjKey* return_key = nullptr) const;
+
+    /// For collections of arithmetic types, return the sum of all elements.
+    /// For non arithmetic types, returns none.
+    util::Optional<Mixed> sum(ColKey column_key) const;
+
+    /// For collections of arithmetic types, return the average of all elements.
+    /// For non arithmetic types, returns none.
+    util::Optional<Mixed> avg(ColKey column_key, size_t* value_count = nullptr) const;
+
     /// Search this view for the specified key. If found, the index of that row
     /// within this view is returned, otherwise `realm::not_found` is returned.
     size_t find_by_source_ndx(ObjKey key) const noexcept
@@ -411,9 +391,7 @@ class TableView : public ObjList {
     size_t m_limit_count = 0;
 
     // A valid query holds a reference to its table which must match our m_table.
-    // hence we can use a query with a null table reference to indicate that the view
-    // was NOT generated by a query, but follows a table directly.
-    Query m_query;
+    std::optional<Query> m_query;
     // parameters for findall, needed to rerun the query
     size_t m_limit = size_t(-1);
 
@@ -440,8 +418,9 @@ class TableView : public ObjList {
 
 private:
     ObjKey find_first_integer(ColKey column_key, int64_t value) const;
-    template <class oper>
-    Timestamp minmax_timestamp(ColKey column_key, ObjKey* return_key) const;
+    template <Action action>
+    std::optional<Mixed> aggregate(ColKey column_key, size_t* count, ObjKey* return_key) const;
+
     util::RaceDetector m_race_detector;
 
     friend class Table;
@@ -471,6 +450,7 @@ inline TableView::TableView(const Query& query, size_t lim)
     , m_limit(lim)
 {
     m_key_values.create();
+    REALM_ASSERT(query.m_table);
 }
 
 inline TableView::TableView(ConstTableRef src_table, ColKey src_column_key, const Obj& obj)
diff --git a/test/object-store/benchmarks/results.cpp b/test/object-store/benchmarks/results.cpp
index 4bfaf370f64..dd5c8c376cf 100644
--- a/test/object-store/benchmarks/results.cpp
+++ b/test/object-store/benchmarks/results.cpp
@@ -334,3 +334,88 @@ TEST_CASE("Benchmark results notifier", "[benchmark]") {
         };
     }
 }
+
+TEST_CASE("aggregates") {
+    InMemoryTestFile config;
+    config.schema = Schema{
+        {"object",
+         {
+             {"value", PropertyType::Int},
+         }},
+        {"link",
+         {
+             {"list", PropertyType::Object | PropertyType::Array, "object"},
+             {"set", PropertyType::Object | PropertyType::Set, "object"},
+             {"dictionary", PropertyType::Object | PropertyType::Dictionary | PropertyType::Nullable, "object"},
+         }},
+        {"primitive",
+         {
+             {"list", PropertyType::Int | PropertyType::Array},
+             {"set", PropertyType::Int | PropertyType::Set},
+             {"dictionary", PropertyType::Int | PropertyType::Dictionary},
+         }},
+    };
+
+    auto realm = Realm::get_shared_realm(config);
+    auto table = realm->read_group().get_table("class_object");
+    auto link_table = realm->read_group().get_table("class_link");
+    auto prim_table = realm->read_group().get_table("class_primitive");
+
+    realm->begin_transaction();
+
+    auto link_obj = link_table->create_object();
+    auto obj_list = link_obj.get_linklist("list");
+    auto obj_set = link_obj.get_linkset(link_obj.get_table()->get_column_key("set"));
+    auto obj_dict = link_obj.get_dictionary("dictionary");
+
+    auto prim_obj = prim_table->create_object();
+    auto int_list = prim_obj.get_list<int64_t>("list");
+    auto int_set = prim_obj.get_set<int64_t>("set");
+    auto int_dict = prim_obj.get_dictionary("dictionary");
+
+    const auto value_count = GENERATE(0, 100, 1'000'000);
+    for (int i = 0; i < value_count; ++i) {
+        auto key = table->create_object().set_all(1LL).get_key();
+        obj_list.add(key);
+        obj_set.insert(key);
+        obj_dict.insert(std::to_string(i), key);
+        int_list.add(1);
+        int_set.insert(i);
+        int_dict.insert(std::to_string(i), 1);
+    }
+    realm->commit_transaction();
+
+    ColKey col = table->get_column_key("value");
+    Results table_results(realm, table);
+    Results query_results(realm, table->where());
+    Results tv_results(realm, table->where());
+    tv_results.evaluate_query_if_needed();
+
+    BENCHMARK("table") {
+        return table_results.sum(col);
+    };
+    BENCHMARK("query") {
+        return query_results.sum(col);
+    };
+    BENCHMARK("tableview") {
+        return tv_results.sum(col);
+    };
+    BENCHMARK("object list") {
+        return List(realm, obj_list).sum(col);
+    };
+    BENCHMARK("object set") {
+        return object_store::Set(realm, obj_set).sum(col);
+    };
+    BENCHMARK("object dictionary") {
+        return object_store::Dictionary(realm, obj_dict).sum(col);
+    };
+    BENCHMARK("int list") {
+        return List(realm, int_list).sum();
+    };
+    BENCHMARK("int set") {
+        return object_store::Set(realm, int_set).sum();
+    };
+    BENCHMARK("int dictionary") {
+        return object_store::Dictionary(realm, int_dict).sum();
+    };
+}
diff --git a/test/object-store/dictionary.cpp b/test/object-store/dictionary.cpp
index 46e90325330..051e1da9fe3 100644
--- a/test/object-store/dictionary.cpp
+++ b/test/object-store/dictionary.cpp
@@ -940,42 +940,54 @@ TEMPLATE_TEST_CASE("dictionary of objects", "[dictionary][links]", cf::MixedVal,
 
     SECTION("min()") {
         if (!TestType::can_minmax()) {
+            REQUIRE_THROWS_AS(dict.min(col_target_value), Results::UnsupportedColumnTypeException);
             REQUIRE_THROWS_AS(values_as_results.min(col_target_value), Results::UnsupportedColumnTypeException);
             return;
         }
+        REQUIRE(Mixed(TestType::min()) == dict.min(col_target_value));
         REQUIRE(Mixed(TestType::min()) == values_as_results.min(col_target_value));
         dict.remove_all();
+        REQUIRE(!dict.min(col_target_value));
         REQUIRE(!values_as_results.min(col_target_value));
     }
 
     SECTION("max()") {
         if (!TestType::can_minmax()) {
+            REQUIRE_THROWS_AS(dict.max(col_target_value), Results::UnsupportedColumnTypeException);
             REQUIRE_THROWS_AS(values_as_results.max(col_target_value), Results::UnsupportedColumnTypeException);
             return;
         }
+        REQUIRE(Mixed(TestType::max()) == dict.max(col_target_value));
         REQUIRE(Mixed(TestType::max()) == values_as_results.max(col_target_value));
         dict.remove_all();
+        REQUIRE(!dict.max(col_target_value));
         REQUIRE(!values_as_results.max(col_target_value));
     }
 
     SECTION("sum()") {
         if (!TestType::can_sum()) {
+            REQUIRE_THROWS_AS(dict.sum(col_target_value), Results::UnsupportedColumnTypeException);
             REQUIRE_THROWS_AS(values_as_results.sum(col_target_value), Results::UnsupportedColumnTypeException);
             return;
         }
+        REQUIRE(cf::get<W>(dict.sum(col_target_value)) == TestType::sum());
         REQUIRE(cf::get<W>(*values_as_results.sum(col_target_value)) == TestType::sum());
         dict.remove_all();
+        REQUIRE(dict.sum(col_target_value) == 0);
         REQUIRE(values_as_results.sum(col_target_value) == 0);
     }
 
     SECTION("average()") {
         if (!TestType::can_average()) {
+            REQUIRE_THROWS_AS(dict.average(col_target_value), Results::UnsupportedColumnTypeException);
             REQUIRE_THROWS_AS(values_as_results.average(col_target_value), Results::UnsupportedColumnTypeException);
             return;
         }
+        REQUIRE(cf::get<typename TestType::AvgType>(*dict.average(col_target_value)) == TestType::average());
         REQUIRE(cf::get<typename TestType::AvgType>(*values_as_results.average(col_target_value)) ==
                 TestType::average());
         dict.remove_all();
+        REQUIRE(!dict.average(col_target_value));
         REQUIRE(!values_as_results.average(col_target_value));
     }
 }
diff --git a/test/object-store/primitive_list.cpp b/test/object-store/primitive_list.cpp
index 0ac9cbee796..7aead477b0e 100644
--- a/test/object-store/primitive_list.cpp
+++ b/test/object-store/primitive_list.cpp
@@ -513,8 +513,8 @@ TEMPLATE_TEST_CASE("primitive list", "[primitives]", cf::MixedVal, cf::Int, cf::
             return;
         }
 
-        REQUIRE(cf::get<W>(*list.max()) == TestType::max());
-        REQUIRE(cf::get<W>(*results.max()) == TestType::max());
+        REQUIRE(cf::get<W>(list.max().value()) == TestType::max());
+        REQUIRE(cf::get<W>(results.max().value()) == TestType::max());
         list.remove_all();
         REQUIRE(list.max() == util::none);
         REQUIRE(results.max() == util::none);
diff --git a/test/test_column_timestamp.cpp b/test/test_column_timestamp.cpp
index e6b175089a0..1de4023bffd 100644
--- a/test/test_column_timestamp.cpp
+++ b/test/test_column_timestamp.cpp
@@ -325,36 +325,36 @@ TEST(TimestampColumn_AggregateBug)
     t.create_objects(4, keys);
     tv = t.where().find_all();
     CHECK_EQUAL(4, tv.size());
-    ts = tv.maximum_timestamp(col, &index);
+    CHECK(tv.max(col, &index)->is_null());
     CHECK_EQUAL(null_key, index);
-    ts = tv.minimum_timestamp(col, &index);
+    CHECK(tv.min(col, &index)->is_null());
     CHECK_EQUAL(null_key, index);
 
-    Query q;
+    Query q = t.where();
 
-    ts = t.where().maximum_timestamp(col, &index);
+    CHECK(q.max(col, &index)->is_null());
     CHECK_EQUAL(null_key, index);
 
-    ts = t.where().minimum_timestamp(col, &index);
+    CHECK(q.min(col, &index)->is_null());
     CHECK_EQUAL(null_key, index);
 
     t.get_object(keys[2]).set(col, Timestamp(1, 0));
 
-    ts = t.where().maximum_timestamp(col, &index);
+    ts = q.max(col, &index)->get_timestamp();
     CHECK_EQUAL(keys[2], index);
     CHECK_EQUAL(ts, Timestamp(1, 0));
 
-    ts = t.where().minimum_timestamp(col, &index);
+    ts = q.min(col, &index)->get_timestamp();
     CHECK_EQUAL(keys[2], index);
     CHECK_EQUAL(ts, Timestamp(1, 0));
 
     t.get_object(keys[3]).set(col, Timestamp(1, 1));
 
-    ts = t.where().maximum_timestamp(col, &index);
+    ts = q.max(col, &index)->get_timestamp();
     CHECK_EQUAL(keys[3], index);
     CHECK_EQUAL(ts, Timestamp(1, 1));
 
-    ts = t.where().minimum_timestamp(col, &index);
+    ts = q.min(col, &index)->get_timestamp();
     CHECK_EQUAL(keys[2], index);
     CHECK_EQUAL(ts, Timestamp(1, 0));
 }
diff --git a/test/test_decimal128.cpp b/test/test_decimal128.cpp
index afbc64ba804..9844aa5e02e 100644
--- a/test/test_decimal128.cpp
+++ b/test/test_decimal128.cpp
@@ -295,26 +295,26 @@ TEST(Decimal_Query)
             }
         }
         size_t actual;
-        CHECK_EQUAL(table->where().equal(col_int, 3).sum_decimal128(col), sum);
-        CHECK_EQUAL(table->where().equal(col_int, 3).average_decimal128(col, &actual), sum / cnt);
+        CHECK_EQUAL(table->where().equal(col_int, 3).sum(col)->get_decimal(), sum);
+        CHECK_EQUAL(table->where().equal(col_int, 3).avg(col, &actual)->get_decimal(), sum / cnt);
         CHECK_EQUAL(actual, cnt);
-        CHECK_EQUAL(table->where().equal(col_int, 3).maximum_decimal128(col), max);
-        CHECK_EQUAL(table->where().equal(col_int, 3).minimum_decimal128(col), min);
-        CHECK_EQUAL(table->where().equal(col_str, "Nice").sum_decimal128(col), Decimal128(285));
-        CHECK_EQUAL(table->where().equal(col_str, "Nice").average_decimal128(col), Decimal128(57));
-        CHECK_EQUAL(table->where().equal(col_str, "Nice").maximum_decimal128(col), Decimal128(95));
-        CHECK_EQUAL(table->where().equal(col_str, "Nice").minimum_decimal128(col), Decimal128(19));
-        CHECK_EQUAL(table->where().average_decimal128(col), Decimal128(50));
+        CHECK_EQUAL(table->where().equal(col_int, 3).max(col)->get_decimal(), max);
+        CHECK_EQUAL(table->where().equal(col_int, 3).min(col)->get_decimal(), min);
+        CHECK_EQUAL(table->where().equal(col_str, "Nice").sum(col)->get_decimal(), Decimal128(285));
+        CHECK_EQUAL(table->where().equal(col_str, "Nice").avg(col)->get_decimal(), Decimal128(57));
+        CHECK_EQUAL(table->where().equal(col_str, "Nice").max(col)->get_decimal(), Decimal128(95));
+        CHECK_EQUAL(table->where().equal(col_str, "Nice").min(col)->get_decimal(), Decimal128(19));
+        CHECK_EQUAL(table->where().avg(col)->get_decimal(), Decimal128(50));
 
         table = rt->get_table("Bar");
         col = table->get_column_key("dummy");
-        CHECK_EQUAL(table->where().average_decimal128(col, &actual), Decimal128(0));
+        CHECK(table->where().avg(col, &actual)->is_null());
         CHECK_EQUAL(actual, 0);
-        CHECK_EQUAL(table->where().sum_decimal128(col), Decimal128(0));
+        CHECK_EQUAL(table->where().sum(col)->get_decimal(), Decimal128(0));
         ObjKey k;
-        CHECK_EQUAL(table->where().maximum_decimal128(col, &k), Decimal128(0));
+        CHECK(table->where().max(col, &k)->is_null());
         CHECK_NOT(k);
-        CHECK_EQUAL(table->where().minimum_decimal128(col, &k), Decimal128(0));
+        CHECK(table->where().min(col, &k)->is_null());
         CHECK_NOT(k);
     }
 }
@@ -376,9 +376,9 @@ TEST(Decimal_Aggregates)
         auto col = table->get_column_key("price");
         CHECK_EQUAL(table->count_decimal(col, Decimal128(51)), 1);
         CHECK_EQUAL(table->count_decimal(col, Decimal128(31)), 2);
-        CHECK_EQUAL(table->sum_decimal(col), Decimal128(sum));
-        CHECK_EQUAL(table->average_decimal(col), Decimal128(sum) / count);
-        CHECK_EQUAL(table->maximum_decimal(col), Decimal128(59));
-        CHECK_EQUAL(table->minimum_decimal(col), Decimal128(1));
+        CHECK_EQUAL(table->sum(col)->get_decimal(), Decimal128(sum));
+        CHECK_EQUAL(table->avg(col)->get_decimal(), Decimal128(sum) / count);
+        CHECK_EQUAL(table->max(col)->get_decimal(), Decimal128(59));
+        CHECK_EQUAL(table->min(col)->get_decimal(), Decimal128(1));
     }
 }
diff --git a/test/test_lang_bind_helper.cpp b/test/test_lang_bind_helper.cpp
index fc6df369b7a..d55347bdad0 100644
--- a/test/test_lang_bind_helper.cpp
+++ b/test/test_lang_bind_helper.cpp
@@ -1699,7 +1699,7 @@ TEST(LangBindHelper_AdvanceReadTransact_TableClear)
     // key is still there...
     CHECK(tv.get_key(0));
     // but no obj for that key...
-    CHECK_THROW(tv.get_object(0), realm::KeyNotFound);
+    CHECK_NOT(tv.get_object(0).is_valid());
 
     tv.sync_if_needed();
     CHECK_EQUAL(tv.size(), 0);
@@ -5039,8 +5039,7 @@ TEST(LangBindHelper_TableViewAggregateAfterAdvanceRead)
     // Verify that an aggregate on the view with detached refs gives the expected result.
     CHECK_EQUAL(false, view.is_in_sync());
     ObjKey res;
-    double min = view.minimum_double(col, &res);
-    CHECK_EQUAL(0, min);
+    CHECK(view.min(col, &res)->is_null());
     CHECK_EQUAL(ObjKey(), res);
 
     // Sync the view to discard the detached refs.
@@ -5048,8 +5047,7 @@ TEST(LangBindHelper_TableViewAggregateAfterAdvanceRead)
 
     // Verify that an aggregate on the view still gives the expected result.
     res = ObjKey();
-    min = view.minimum_double(col, &res);
-    CHECK_EQUAL(0, min);
+    CHECK(view.min(col, &res)->is_null());
     CHECK_EQUAL(ObjKey(), res);
 }
 
diff --git a/test/test_metrics.cpp b/test/test_metrics.cpp
index 95dd3ab13a9..b0d8b119e04 100644
--- a/test/test_metrics.cpp
+++ b/test/test_metrics.cpp
@@ -145,24 +145,24 @@ TEST(Metrics_QueryTypes)
     query.find();
     query.find_all();
     query.count();
-    query.sum_int(int_col);
-    query.average_int(int_col);
-    query.maximum_int(int_col);
-    query.minimum_int(int_col);
+    query.sum(int_col);
+    query.avg(int_col);
+    query.max(int_col);
+    query.min(int_col);
 
-    query.sum_double(double_col);
-    query.average_double(double_col);
-    query.maximum_double(double_col);
-    query.minimum_double(double_col);
+    query.sum(double_col);
+    query.avg(double_col);
+    query.max(double_col);
+    query.min(double_col);
 
-    query.sum_float(float_col);
-    query.average_float(float_col);
-    query.maximum_float(float_col);
-    query.minimum_float(float_col);
+    query.sum(float_col);
+    query.avg(float_col);
+    query.max(float_col);
+    query.min(float_col);
 
     ObjKey return_dummy;
-    query.maximum_timestamp(timestamp_col, &return_dummy);
-    query.minimum_timestamp(timestamp_col, &return_dummy);
+    query.max(timestamp_col, &return_dummy);
+    query.min(timestamp_col, &return_dummy);
 
     rt->end_read();
     std::shared_ptr<Metrics> metrics = sg->get_metrics();
diff --git a/test/test_query.cpp b/test/test_query.cpp
index b8405e0a87d..0406576c342 100644
--- a/test/test_query.cpp
+++ b/test/test_query.cpp
@@ -3201,39 +3201,39 @@ TEST(Query_Float3)
     t.create_object().set_all(float(1.9), double(2.9), 9);
 
     Query q1 = t.where().greater(col_float, 1.35f).less(col_double, 2.65);
-    int64_t a1 = q1.sum_int(col_int);
+    auto a1 = q1.sum(col_int);
     CHECK_EQUAL(15, a1);
 
     Query q2 = t.where().less(col_double, 2.65).greater(col_float, 1.35f);
-    int64_t a2 = q2.sum_int(col_int);
+    auto a2 = q2.sum(col_int);
     CHECK_EQUAL(15, a2);
 
     Query q3 = t.where().less(col_double, 2.65).greater(col_float, 1.35f);
-    double a3 = q3.sum_float(col_float);
+    auto a3 = q3.sum(col_float);
     double sum3 = double(1.4f) + double(1.5f) + double(1.6f);
     CHECK_EQUAL(sum3, a3);
 
     Query q4 = t.where().greater(col_float, 1.35f).less(col_double, 2.65);
-    double a4 = q4.sum_float(col_float);
+    auto a4 = q4.sum(col_float);
     CHECK_EQUAL(sum3, a4);
 
     Query q5 = t.where().greater_equal(col_int, 4).less(col_double, 2.65);
-    double a5 = q5.sum_float(col_float);
+    auto a5 = q5.sum(col_float);
     CHECK_EQUAL(sum3, a5);
 
     Query q6 = t.where().less(col_double, 2.65).greater_equal(col_int, 4);
-    double a6 = q6.sum_float(col_float);
+    auto a6 = q6.sum(col_float);
     CHECK_EQUAL(sum3, a6);
 
     Query q7 = t.where().greater(col_int, 3).less(col_int, 7);
-    int64_t a7 = q7.sum_int(col_int);
+    auto a7 = q7.sum(col_int);
     CHECK_EQUAL(15, a7);
     Query q8 = t.where().greater(col_int, 3).less(col_int, 7);
-    int64_t a8 = q8.sum_int(col_int);
+    auto a8 = q8.sum(col_int);
     CHECK_EQUAL(15, a8);
 
     q8 = t.where().greater(col_int, 3);
-    float f = float(q8.sum_float(col_float));
+    float f = float(q8.sum(col_float)->get_double());
     CHECK_EQUAL(8.1f, f);
 }
 
@@ -3259,40 +3259,40 @@ TEST(Query_Float3_where)
     TableView v = t.where().find_all();
 
     Query q1 = t.where(&v).greater(col_float, 1.35f).less(col_double, 2.65);
-    int64_t a1 = q1.sum_int(col_int);
+    auto a1 = q1.sum(col_int);
     CHECK_EQUAL(15, a1);
 
     ObjKey k;
-    a1 = q1.maximum_int(col_int, &k);
+    a1 = q1.max(col_int, &k);
     CHECK_EQUAL(k.value, 0xc001ede1b0);
     CHECK_EQUAL(a1, 6);
 
     Query q2 = t.where(&v).less(col_double, 2.65).greater(col_float, 1.35f);
-    int64_t a2 = q2.sum_int(col_int);
+    auto a2 = q2.sum(col_int);
     CHECK_EQUAL(15, a2);
 
     Query q3 = t.where(&v).less(col_double, 2.65).greater(col_float, 1.35f);
-    double a3 = q3.sum_float(col_float);
+    auto a3 = q3.sum(col_float)->get_double();
     double sum3 = double(1.4f) + double(1.5f) + double(1.6f);
     CHECK_EQUAL(sum3, a3);
 
     Query q4 = t.where(&v).greater(col_float, 1.35f).less(col_double, 2.65);
-    double a4 = q4.sum_float(col_float);
+    auto a4 = q4.sum(col_float)->get_double();
     CHECK_EQUAL(sum3, a4);
 
     Query q5 = t.where(&v).greater_equal(col_int, 4).less(col_double, 2.65);
-    double a5 = q5.sum_float(col_float);
+    auto a5 = q5.sum(col_float)->get_double();
     CHECK_EQUAL(sum3, a5);
 
     Query q6 = t.where(&v).less(col_double, 2.65).greater_equal(col_int, 4);
-    double a6 = q6.sum_float(col_float);
+    auto a6 = q6.sum(col_float)->get_double();
     CHECK_EQUAL(sum3, a6);
 
     Query q7 = t.where(&v).greater(col_int, 3).less(col_int, 7);
-    int64_t a7 = q7.sum_int(col_int);
+    auto a7 = q7.sum(col_int);
     CHECK_EQUAL(15, a7);
     Query q8 = t.where(&v).greater(col_int, 3).less(col_int, 7);
-    int64_t a8 = q8.sum_int(col_int);
+    auto a8 = q8.sum(col_int);
     CHECK_EQUAL(15, a8);
 }
 
@@ -3308,13 +3308,12 @@ TEST(Query_TableViewSum)
 
     Query q1 = t.where().between(col_int, 5, 9);
     TableView tv1 = q1.find_all();
-    int64_t s = tv1.sum_int(col_int);
-    CHECK_EQUAL(5 + 6 + 7 + 8 + 9, s);
+    CHECK_EQUAL(5 + 6 + 7 + 8 + 9, *tv1.sum(col_int));
 }
 
 TEST(Query_JavaMinimumCrash)
 {
-    // Test that triggers a bug that was discovered through Java intnerface and has been fixed
+    // Test that triggers a bug that was discovered through Java interface and has been fixed
     Table ttt;
 
     auto col_str = ttt.add_column(type_String, "1");
@@ -3326,8 +3325,7 @@ TEST(Query_JavaMinimumCrash)
     ttt.create_object().set_all("Bob", "Hanson", 3);
 
     Query q1 = ttt.where().equal(col_str, "Joe").Or().equal(col_str, "Bob");
-    int64_t m = q1.minimum_int(col_int);
-    CHECK_EQUAL(1, m);
+    CHECK_EQUAL(1, *q1.min(col_int));
 }
 
 
@@ -3344,15 +3342,15 @@ TEST(Query_Float4)
     t.create_object().set_all(12345.0f, 12345.0, 11111);
 
     Query q1 = t.where();
-    float a1 = q1.maximum_float(col_float);
-    double a2 = q1.maximum_double(col_double);
+    auto a1 = q1.max(col_float)->get_float();
+    auto a2 = q1.max(col_double)->get_double();
     CHECK_EQUAL(std::numeric_limits<float>::infinity(), a1);
     CHECK_EQUAL(std::numeric_limits<double>::infinity(), a2);
 
 
     Query q2 = t.where();
-    float a3 = q1.minimum_float(col_float);
-    double a4 = q1.minimum_double(col_double);
+    auto a3 = q1.min(col_float);
+    auto a4 = q1.min(col_double);
     CHECK_EQUAL(12345.0, a3);
     CHECK_EQUAL(12345.0, a4);
 }
@@ -3402,64 +3400,64 @@ TEST(Query_Float)
     // ------ Test sum()
     // ... NO conditions
     double sum1_d = 2.20 + 2.21 + 2.22 + 2.20 + 3.20;
-    CHECK_APPROXIMATELY_EQUAL(sum1_d, t.where().sum_double(col_double), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum1_d, t.where().sum(col_double)->get_double(), 10 * epsilon);
 
     // Note: sum of float is calculated by having a double aggregate to where each float is added
     // (thereby getting casted to double).
     double sum1_f = double(1.10f) + double(1.13f) + double(1.13f) + double(1.10f) + double(1.20f);
-    double res = t.where().sum_float(col_float);
+    double res = t.where().sum(col_float)->get_double();
     CHECK_APPROXIMATELY_EQUAL(sum1_f, res, 10 * epsilon);
 
     // ... with conditions
     double sum2_f = double(1.13f) + double(1.20f);
     double sum2_d = 2.21 + 3.20;
     Query q2 = t.where().between(col_float, 1.13f, 1.20f).not_equal(col_double, 2.22);
-    CHECK_APPROXIMATELY_EQUAL(sum2_f, q2.sum_float(col_float), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(sum2_d, q2.sum_double(col_double), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum2_f, q2.sum(col_float)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum2_d, q2.sum(col_double)->get_double(), 10 * epsilon);
 
     // ------ Test average()
 
     // ... NO conditions
-    CHECK_APPROXIMATELY_EQUAL(sum1_f / 5, t.where().average_float(col_float), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(sum1_d / 5, t.where().average_double(col_double), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum1_f / 5, t.where().avg(col_float)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum1_d / 5, t.where().avg(col_double)->get_double(), 10 * epsilon);
     // ... with conditions
-    CHECK_APPROXIMATELY_EQUAL(sum2_f / 2, q2.average_float(col_float), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(sum2_d / 2, q2.average_double(col_double), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum2_f / 2, q2.avg(col_float)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum2_d / 2, q2.avg(col_double)->get_double(), 10 * epsilon);
 
     // -------- Test minimum(), maximum()
 
     ObjKey ndx;
 
     // ... NO conditions
-    CHECK_EQUAL(1.20f, t.where().maximum_float(col_float));
-    t.where().maximum_float(col_float, &ndx);
+    CHECK_EQUAL(1.20f, t.where().max(col_float));
+    t.where().max(col_float, &ndx);
     CHECK_EQUAL(k4, ndx);
 
-    CHECK_EQUAL(1.10f, t.where().minimum_float(col_float));
-    t.where().minimum_float(col_float, &ndx);
+    CHECK_EQUAL(1.10f, t.where().min(col_float));
+    t.where().min(col_float, &ndx);
     CHECK_EQUAL(k0, ndx);
 
-    CHECK_EQUAL(3.20, t.where().maximum_double(col_double));
-    CHECK_EQUAL(3.20, t.where().maximum_double(col_double, &ndx));
+    CHECK_EQUAL(3.20, t.where().max(col_double));
+    CHECK_EQUAL(3.20, t.where().max(col_double, &ndx));
 
-    CHECK_EQUAL(2.20, t.where().minimum_double(col_double));
-    t.where().minimum_double(col_double, &ndx);
+    CHECK_EQUAL(2.20, t.where().min(col_double));
+    t.where().min(col_double, &ndx);
 
     // ... with conditions
-    CHECK_EQUAL(1.20f, q2.maximum_float(col_float));
-    q2.maximum_float(col_float, &ndx);
+    CHECK_EQUAL(1.20f, q2.max(col_float));
+    q2.max(col_float, &ndx);
     CHECK_EQUAL(k4, ndx);
 
-    CHECK_EQUAL(1.13f, q2.minimum_float(col_float));
-    q2.minimum_float(col_float, &ndx);
+    CHECK_EQUAL(1.13f, q2.min(col_float));
+    q2.min(col_float, &ndx);
     CHECK_EQUAL(k1, ndx);
 
-    CHECK_EQUAL(3.20, q2.maximum_double(col_double));
-    q2.maximum_double(col_double, &ndx);
+    CHECK_EQUAL(3.20, q2.max(col_double));
+    q2.max(col_double, &ndx);
     CHECK_EQUAL(k4, ndx);
 
-    CHECK_EQUAL(2.21, q2.minimum_double(col_double));
-    q2.minimum_double(col_double, &ndx);
+    CHECK_EQUAL(2.21, q2.min(col_double));
+    q2.min(col_double, &ndx);
     CHECK_EQUAL(k1, ndx);
 }
 
@@ -3514,13 +3512,13 @@ TEST_TYPES(Query_StrIndexed, std::true_type, std::false_type)
 
     ttt.add_search_index(col_str);
 
-    int64_t s = ttt.where().equal(col_str, "a").sum_int(col_int);
+    auto s = *ttt.where().equal(col_str, "a").sum(col_int);
     CHECK_EQUAL(10 * 11, s);
 
-    s = ttt.where().equal(col_str, "a").equal(col_int, 10).sum_int(col_int);
+    s = *ttt.where().equal(col_str, "a").equal(col_int, 10).sum(col_int);
     CHECK_EQUAL(100, s);
 
-    s = ttt.where().equal(col_int, 10).equal(col_str, "a").sum_int(col_int);
+    s = *ttt.where().equal(col_int, 10).equal(col_str, "a").sum(col_int);
     CHECK_EQUAL(100, s);
 
     TableView tv = ttt.where().equal(col_str, "a").find_all();
@@ -3591,7 +3589,7 @@ TEST(Query_SumMinMaxAvgForeignCol)
     t.create_object().set_all(2, 30);
     t.create_object().set_all(4, 40);
 
-    CHECK_EQUAL(50, t.where().equal(col_int0, 2).sum_int(col_int1));
+    CHECK_EQUAL(50, t.where().equal(col_int0, 2).sum(col_int1));
 }
 
 TEST(Query_AggregateSingleCond)
@@ -3606,16 +3604,16 @@ TEST(Query_AggregateSingleCond)
     t.create_object().set(col_int, 3);
     t.create_object().set(col_int, 4);
 
-    int64_t s = t.where().equal(col_int, 2).sum_int(col_int);
+    auto s = t.where().equal(col_int, 2).sum(col_int);
     CHECK_EQUAL(4, s);
 
-    s = t.where().greater(col_int, 2).sum_int(col_int);
+    s = t.where().greater(col_int, 2).sum(col_int);
     CHECK_EQUAL(10, s);
 
-    s = t.where().less(col_int, 3).sum_int(col_int);
+    s = t.where().less(col_int, 3).sum(col_int);
     CHECK_EQUAL(5, s);
 
-    s = t.where().not_equal(col_int, 3).sum_int(col_int);
+    s = t.where().not_equal(col_int, 3).sum(col_int);
     CHECK_EQUAL(9, s);
 }
 
@@ -5109,7 +5107,7 @@ TEST(Query_Sort_And_Requery_FindFirst)
 
     // 3, 2, 3, 2
     ObjKey k = ttt.where(&tv).equal(col_int0, 3).find();
-    int64_t s = ttt.where(&tv).not_equal(col_int1, 40).sum_int(col_int0);
+    auto s = ttt.where(&tv).not_equal(col_int1, 40).sum(col_int0);
     CHECK_EQUAL(k, ObjKey(5));
     CHECK_EQUAL(s, 7);
 }
@@ -5564,7 +5562,7 @@ NONCONCURRENT_TEST(Query_IntPerformance)
     auto t3 = steady_clock::now();
 
     for (size_t t = 0; t < nb_reps; t++) {
-        auto sum = q2.sum_int(col_2);
+        auto sum = q2.sum(col_2);
         CHECK_EQUAL(sum, 1998);
     }
 
diff --git a/test/test_query2.cpp b/test/test_query2.cpp
index d9bd7696d20..fb39c0c7ebb 100644
--- a/test/test_query2.cpp
+++ b/test/test_query2.cpp
@@ -911,67 +911,67 @@ TEST(Query_SumMinMaxAvg)
     t.get_object(keys[7]).set_all(0, Timestamp{3000, 0}, 30.0f, 30.0, Decimal128{8.8}, Mixed{42});
     t.get_object(keys[8]).set_all(0, Timestamp{5, 0}, 0.5f, 0.5, Decimal128{9.9}, Mixed{0.1});
 
-    CHECK_EQUAL(9, t.where().sum_int(int_col));
-
-    CHECK_EQUAL(0, t.where().minimum_int(int_col));
-    CHECK_EQUAL(3, t.where().maximum_int(int_col));
-    CHECK_EQUAL(Decimal128{9.9}, t.where().maximum_decimal128(decimal_col));
-    CHECK_EQUAL(Mixed{"foo"}, t.where().maximum_mixed(mixed_col));
-    CHECK_EQUAL(Decimal128{1.1}, t.where().minimum_decimal128(decimal_col));
-    CHECK_EQUAL(Mixed{0.1}, t.where().minimum_mixed(mixed_col));
-    CHECK_EQUAL(Decimal128{49.5}, t.where().sum_decimal128(decimal_col));
-    CHECK_EQUAL(Mixed{48.5}, t.where().sum_mixed(mixed_col));
-    CHECK_EQUAL(Decimal128{49.5 / 9}, t.where().average_decimal128(decimal_col));
-    Decimal128 avg_mixed = t.where().average_mixed(mixed_col);
+    CHECK_EQUAL(9, *t.where().sum(int_col));
+
+    CHECK_EQUAL(0, *t.where().min(int_col));
+    CHECK_EQUAL(3, *t.where().max(int_col));
+    CHECK_EQUAL(Decimal128{9.9}, t.where().max(decimal_col));
+    CHECK_EQUAL(Mixed{"foo"}, t.where().max(mixed_col));
+    CHECK_EQUAL(Decimal128{1.1}, t.where().min(decimal_col));
+    CHECK_EQUAL(Mixed{0.1}, t.where().min(mixed_col));
+    CHECK_EQUAL(Decimal128{49.5}, t.where().sum(decimal_col));
+    CHECK_EQUAL(Mixed{48.5}, t.where().sum(mixed_col));
+    CHECK_EQUAL(Decimal128{49.5 / 9}, t.where().avg(decimal_col));
+    Decimal128 avg_mixed = t.where().avg(mixed_col)->get_decimal();
     Decimal128 expected_avg_mixed = Decimal128{48.5 / 6};
     Decimal128 allowed_epsilon{0.001};
     CHECK(avg_mixed <= (expected_avg_mixed + allowed_epsilon) && avg_mixed >= (expected_avg_mixed - allowed_epsilon));
     t.get_object(keys[6]).set<Mixed>(mixed_col, Mixed{false});
-    CHECK_EQUAL(Mixed{false}, t.where().minimum_mixed(mixed_col));
+    CHECK_EQUAL(Mixed{false}, t.where().min(mixed_col));
 
     ObjKey resindex;
 
-    t.where().maximum_int(int_col, &resindex);
+    t.where().max(int_col, &resindex);
     CHECK_EQUAL(keys[5], resindex);
 
-    t.where().minimum_int(int_col, &resindex);
+    t.where().min(int_col, &resindex);
     CHECK_EQUAL(keys[6], resindex);
 
-    t.where().maximum_float(float_col, &resindex);
+    t.where().max(float_col, &resindex);
     CHECK_EQUAL(keys[7], resindex);
 
-    t.where().minimum_float(float_col, &resindex);
+    t.where().min(float_col, &resindex);
     CHECK_EQUAL(keys[8], resindex);
 
-    t.where().maximum_double(double_col, &resindex);
+    t.where().max(double_col, &resindex);
     CHECK_EQUAL(keys[7], resindex);
 
-    t.where().minimum_double(double_col, &resindex);
+    t.where().min(double_col, &resindex);
     CHECK_EQUAL(keys[8], resindex);
 
-    t.where().maximum_timestamp(date_col, &resindex);
+    t.where().max(date_col, &resindex);
     CHECK_EQUAL(keys[7], resindex);
 
-    t.where().minimum_timestamp(date_col, &resindex);
+    t.where().min(date_col, &resindex);
     CHECK_EQUAL(keys[8], resindex);
 
     // Now with condition (tests another code path in Array::minmax())
-    t.where().not_equal(int_col, 0).minimum_double(double_col, &resindex);
+    t.where().not_equal(int_col, 0).min(double_col, &resindex);
     CHECK_EQUAL(keys[1], resindex);
 
-    t.where().not_equal(int_col, 0).minimum_float(float_col, &resindex);
+    t.where().not_equal(int_col, 0).min(float_col, &resindex);
     CHECK_EQUAL(keys[0], resindex);
 
-    t.where().not_equal(int_col, 0).minimum_timestamp(date_col, &resindex);
+    t.where().not_equal(int_col, 0).min(date_col, &resindex);
     CHECK_EQUAL(keys[5], resindex);
 
-    t.where().not_equal(int_col, 0).maximum_timestamp(date_col, &resindex);
+    t.where().not_equal(int_col, 0).max(date_col, &resindex);
     CHECK_EQUAL(keys[4], resindex);
 
-    CHECK_APPROXIMATELY_EQUAL(1, t.where().average_int(int_col), 0.001);
+    CHECK_APPROXIMATELY_EQUAL(1, t.where().avg(int_col)->get_double(), 0.001);
 
-    CHECK_EQUAL(t.where().maximum_timestamp(date_col), Timestamp(3000, 0));
-    CHECK_EQUAL(t.where().minimum_timestamp(date_col), Timestamp(5, 0));
+    CHECK_EQUAL(t.where().max(date_col), Timestamp(3000, 0));
+    CHECK_EQUAL(t.where().min(date_col), Timestamp(5, 0));
 }
 
 
@@ -981,9 +981,9 @@ TEST(Query_Avg)
     auto col = t.add_column(type_Int, "1");
 
     t.create_object().set(col, 10);
-    CHECK_EQUAL(10, t.where().average_int(col));
+    CHECK_EQUAL(10, t.where().avg(col));
     t.create_object().set(col, 30);
-    CHECK_EQUAL(20, t.where().average_int(col));
+    CHECK_EQUAL(20, t.where().avg(col));
 }
 
 TEST(Query_Avg2)
@@ -1001,11 +1001,11 @@ TEST(Query_Avg2)
     t.create_object().set_all(100, "b");
     t.create_object().set_all(30, "a");
 
-    CHECK_EQUAL(60, t.where().equal(col_str, "a").sum_int(col_int));
+    CHECK_EQUAL(60, t.where().equal(col_str, "a").sum(col_int));
 
-    CHECK_EQUAL(20, t.where().equal(col_str, "a").average_int(col_int, &cnt));
+    CHECK_EQUAL(20, t.where().equal(col_str, "a").avg(col_int, &cnt));
     CHECK_EQUAL(3, cnt);
-    CHECK_EQUAL(100, t.where().equal(col_str, "b").average_int(col_int, &cnt));
+    CHECK_EQUAL(100, t.where().equal(col_str, "b").avg(col_int, &cnt));
     CHECK_EQUAL(3, cnt);
 }
 
@@ -1088,38 +1088,38 @@ TEST(Query_AllTypesDynamicallyTyped)
 
         ObjKey ndx;
 
-        CHECK_EQUAL(54, query.minimum_int(col_int));
-        query.minimum_int(col_int, &ndx);
+        CHECK_EQUAL(54, query.min(col_int));
+        query.min(col_int, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(54, query.maximum_int(col_int));
-        query.maximum_int(col_int, &ndx);
+        CHECK_EQUAL(54, query.max(col_int));
+        query.max(col_int, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(54, query.sum_int(col_int));
-        CHECK_EQUAL(54, query.average_int(col_int));
+        CHECK_EQUAL(54, query.sum(col_int));
+        CHECK_EQUAL(54, query.avg(col_int));
 
-        CHECK_EQUAL(0.7f, query.minimum_float(col_flt));
-        query.minimum_float(col_flt, &ndx);
+        CHECK_EQUAL(0.7f, query.min(col_flt));
+        query.min(col_flt, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(0.7f, query.maximum_float(col_flt));
-        query.maximum_float(col_flt, &ndx);
+        CHECK_EQUAL(0.7f, query.max(col_flt));
+        query.max(col_flt, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(0.7f, query.sum_float(col_flt));
-        CHECK_EQUAL(0.7f, query.average_float(col_flt));
+        CHECK_EQUAL(0.7f, query.sum(col_flt));
+        CHECK_EQUAL(0.7f, query.avg(col_flt));
 
-        CHECK_EQUAL(0.8, query.minimum_double(col_dbl));
-        query.minimum_double(col_dbl, &ndx);
+        CHECK_EQUAL(0.8, query.min(col_dbl));
+        query.min(col_dbl, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(0.8, query.maximum_double(col_dbl));
-        query.maximum_double(col_dbl, &ndx);
+        CHECK_EQUAL(0.8, query.max(col_dbl));
+        query.max(col_dbl, &ndx);
         CHECK_EQUAL(obj0.get_key(), ndx);
 
-        CHECK_EQUAL(0.8, query.sum_double(col_dbl));
-        CHECK_EQUAL(0.8, query.average_double(col_dbl));
+        CHECK_EQUAL(0.8, query.sum(col_dbl));
+        CHECK_EQUAL(0.8, query.avg(col_dbl));
     }
 }
 
@@ -1136,9 +1136,9 @@ TEST(Query_AggregateSortedView)
     TableView tv = table.where().greater(col, 1.0).find_all();
     tv.sort(col, false);
 
-    CHECK_EQUAL(2.0, tv.minimum_double(col));
-    CHECK_EQUAL(count, tv.maximum_double(col));
-    CHECK_APPROXIMATELY_EQUAL((count + 1) * count / 2, tv.sum_double(col), .1);
+    CHECK_EQUAL(2.0, tv.min(col));
+    CHECK_EQUAL(count, tv.max(col));
+    CHECK_APPROXIMATELY_EQUAL((count + 1) * count / 2, tv.sum(col)->get_double(), .1);
 }
 
 
@@ -1975,57 +1975,55 @@ TEST(Query_NullShowcase)
 
     // TableView
     size_t count;
-    int64_t i;
-    double d;
-    Timestamp dt;
+    std::optional<Mixed> m;
     tv = table->where().find_all();
 
     // Integer column
-    i = tv.maximum_int(col_price);
-    CHECK_EQUAL(i, 20);
+    m = tv.max(col_price);
+    CHECK_EQUAL(m, 20);
 
-    i = tv.minimum_int(col_price);
-    CHECK_EQUAL(i, 10);
+    m = tv.min(col_price);
+    CHECK_EQUAL(m, 10);
 
     count = 123;
-    d = tv.average_int(col_price, &count);
-    CHECK_APPROXIMATELY_EQUAL(d, 15., 0.001);
+    m = tv.avg(col_price, &count);
+    CHECK_APPROXIMATELY_EQUAL(m->get_double(), 15., 0.001);
     CHECK_EQUAL(count, 2);
 
-    i = tv.sum_int(col_price);
-    CHECK_EQUAL(i, 30);
+    m = tv.sum(col_price);
+    CHECK_EQUAL(m, 30);
 
 
     // Float column
-    d = tv.maximum_float(col_shipping);
-    CHECK_EQUAL(d, 30.);
+    m = tv.max(col_shipping);
+    CHECK_EQUAL(m, 30.);
 
-    d = tv.minimum_float(col_shipping);
-    CHECK_EQUAL(d, 30.);
+    m = tv.min(col_shipping);
+    CHECK_EQUAL(m, 30.);
 
     count = 123;
-    d = tv.average_float(col_shipping, &count);
-    CHECK_APPROXIMATELY_EQUAL(d, 30., 0.001);
+    m = tv.avg(col_shipping, &count);
+    CHECK_APPROXIMATELY_EQUAL(m->get_double(), 30., 0.001);
     CHECK_EQUAL(count, 1);
 
-    d = tv.sum_float(col_shipping);
-    CHECK_APPROXIMATELY_EQUAL(d, 30., 0.001);
+    m = tv.sum(col_shipping);
+    CHECK_APPROXIMATELY_EQUAL(m->get_double(), 30., 0.001);
 
-    // Double column
-    d = tv.maximum_double(col_rating);
-    CHECK_EQUAL(d, 3.3);
-    d = tv.minimum_double(col_rating);
-    CHECK_EQUAL(d, 1.1);
-    d = tv.average_double(col_rating);
-    CHECK_APPROXIMATELY_EQUAL(d, (1.1 + 2.2 + 3.3) / 3, 0.001);
-    d = tv.sum_double(col_rating);
-    CHECK_APPROXIMATELY_EQUAL(d, 1.1 + 2.2 + 3.3, 0.001);
+    // double column
+    m = tv.max(col_rating);
+    CHECK_EQUAL(m, 3.3);
+    m = tv.min(col_rating);
+    CHECK_EQUAL(m, 1.1);
+    m = tv.avg(col_rating);
+    CHECK_APPROXIMATELY_EQUAL(m->get_double(), (1.1 + 2.2 + 3.3) / 3, 0.001);
+    m = tv.sum(col_rating);
+    CHECK_APPROXIMATELY_EQUAL(m->get_double(), 1.1 + 2.2 + 3.3, 0.001);
 
     // OldDateTime column
-    dt = tv.maximum_timestamp(col_date);
-    CHECK_EQUAL(dt, Timestamp(12345, 67));
-    dt = tv.minimum_timestamp(col_date);
-    CHECK_EQUAL(dt, Timestamp(12345, 0));
+    m = tv.max(col_date);
+    CHECK_EQUAL(m, Timestamp(12345, 67));
+    m = tv.min(col_date);
+    CHECK_EQUAL(m, Timestamp(12345, 0));
 
 #if 0 // FIXME?
     // NaN
@@ -2358,53 +2356,53 @@ TEST(Query_Null_BetweenMinMax_Nullable)
     auto test_tv = [&]() {
         // int
         match = ObjKey(123);
-        tv.maximum_int(col_price, &match);
+        tv.max(col_price, &match);
         CHECK_EQUAL(match, realm::null_key);
 
         match = ObjKey(123);
-        tv.minimum_int(col_price, &match);
+        tv.min(col_price, &match);
         CHECK_EQUAL(match, realm::null_key);
 
-        CHECK_EQUAL(tv.sum_int(col_price), 0);
+        CHECK_EQUAL(tv.sum(col_price), 0);
         count = 123;
-        CHECK_EQUAL(tv.average_int(col_price, &count), 0.);
+        CHECK(tv.avg(col_price, &count)->is_null());
         CHECK_EQUAL(count, 0);
 
         // float
         match = ObjKey(123);
-        tv.maximum_float(col_shipping, &match);
+        CHECK(tv.max(col_shipping, &match)->is_null());
         CHECK_EQUAL(match, realm::null_key);
 
         match = ObjKey(123);
-        tv.minimum_float(col_shipping, &match);
+        CHECK(tv.min(col_shipping, &match)->is_null());
         CHECK_EQUAL(match, realm::null_key);
 
-        CHECK_EQUAL(tv.sum_float(col_shipping), 0.);
+        CHECK_EQUAL(tv.sum(col_shipping), 0.);
         count = 123;
-        CHECK_EQUAL(tv.average_float(col_shipping, &count), 0.);
+        CHECK(tv.avg(col_shipping, &count)->is_null());
         CHECK_EQUAL(count, 0);
 
         // double
         match = ObjKey(123);
-        tv.maximum_double(col_rating, &match);
+        CHECK(tv.max(col_rating, &match)->is_null());
         CHECK_EQUAL(match, realm::null_key);
 
         match = ObjKey(123);
-        tv.minimum_double(col_rating, &match);
+        CHECK(tv.min(col_rating, &match)->is_null());
         CHECK_EQUAL(match, realm::null_key);
 
-        CHECK_EQUAL(tv.sum_double(col_rating), 0.);
+        CHECK_EQUAL(tv.sum(col_rating), 0.);
         count = 123;
-        CHECK_EQUAL(tv.average_double(col_rating, &count), 0.);
+        CHECK(tv.avg(col_rating, &count)->is_null());
         CHECK_EQUAL(count, 0);
 
         // date
         match = ObjKey(123);
-        tv.maximum_timestamp(col_date, &match);
+        tv.max(col_date, &match);
         CHECK_EQUAL(match, realm::null_key);
 
         match = ObjKey(123);
-        tv.minimum_timestamp(col_date, &match);
+        tv.min(col_date, &match);
         CHECK_EQUAL(match, realm::null_key);
     };
 
@@ -2428,13 +2426,13 @@ TEST(Query_Null_BetweenMinMax_Nullable)
 
     tv = table->where().find_all();
     count = 123;
-    CHECK_EQUAL(tv.average_int(col_price, &count), 10);
+    CHECK_EQUAL(tv.avg(col_price, &count), 10);
     CHECK_EQUAL(count, 1);
     count = 123;
-    CHECK_EQUAL(tv.average_float(col_shipping, &count), 10.);
+    CHECK_EQUAL(tv.avg(col_shipping, &count), 10.);
     CHECK_EQUAL(count, 1);
     count = 123;
-    CHECK_EQUAL(tv.average_double(col_rating, &count), 10.);
+    CHECK_EQUAL(tv.avg(col_rating, &count), 10.);
     CHECK_EQUAL(count, 1);
 }
 
@@ -3319,9 +3317,9 @@ TEST(Query_AverageNullableColumns)
     auto col_float = table.add_column(type_Float, "float", true);
     auto col_double = table.add_column(type_Double, "double", true);
 
-    CHECK_EQUAL(0, table.where().average_int(col_int));
-    CHECK_EQUAL(0, table.where().average_float(col_float));
-    CHECK_EQUAL(0, table.where().average_double(col_double));
+    CHECK(table.where().avg(col_int)->is_null());
+    CHECK(table.where().avg(col_float)->is_null());
+    CHECK(table.where().avg(col_double)->is_null());
 
     //
     // +-----+-------+--------+
@@ -3334,17 +3332,17 @@ TEST(Query_AverageNullableColumns)
     table.create_object().set_all(2, 2.0f, 2.0);
     table.create_object().set_all(4, 4.0f, 4.0);
 
-    CHECK_EQUAL(3, table.where().average_int(col_int));
-    CHECK_EQUAL(3, table.where().average_float(col_float));
-    CHECK_EQUAL(3, table.where().average_double(col_double));
+    CHECK_EQUAL(3, table.where().avg(col_int));
+    CHECK_EQUAL(3, table.where().avg(col_float));
+    CHECK_EQUAL(3, table.where().avg(col_double));
 
     // Add a row with nulls in each column. These nulls must be treated as not existing, that is,
     // it must be such that the average of 2 + 2 + null == 2.
     table.create_object();
 
-    CHECK_EQUAL(3, table.where().average_int(col_int));
-    CHECK_EQUAL(3, table.where().average_float(col_float));
-    CHECK_EQUAL(3, table.where().average_double(col_double));
+    CHECK_EQUAL(3, table.where().avg(col_int));
+    CHECK_EQUAL(3, table.where().avg(col_float));
+    CHECK_EQUAL(3, table.where().avg(col_double));
 }
 
 TEST(Query_NegativeNumbers)
@@ -3419,14 +3417,14 @@ TEST_TYPES(Query_EqualityInts, int64_t, util::Optional<int64_t>)
         Query q_eq = table->where().equal(col_ndx, target);
         CHECK_EQUAL(q_eq.find(), obj.get_key());
         CHECK_EQUAL(q_eq.count(), 1);
-        CHECK_EQUAL(q_eq.sum_int(col_ndx), target);
-        CHECK_EQUAL(q_eq.average_int(col_ndx), target);
+        CHECK_EQUAL(q_eq.sum(col_ndx), target);
+        CHECK_EQUAL(q_eq.avg(col_ndx), target);
 
         Query q_neq = table->where().not_equal(col_ndx, target);
         CHECK_EQUAL(q_neq.find(), first ? ObjKey(1) : ObjKey(0));
         CHECK_EQUAL(q_neq.count(), num_rows - 1);
-        CHECK_EQUAL(q_neq.sum_int(col_ndx), sum - target);
-        CHECK_EQUAL(q_neq.average_int(col_ndx), (sum - target) / double(num_rows - 1));
+        CHECK_EQUAL(q_neq.sum(col_ndx), sum - target);
+        CHECK_EQUAL(q_neq.avg(col_ndx), (sum - target) / double(num_rows - 1));
         first = false;
     }
 }
@@ -3458,260 +3456,256 @@ TEST(Query_MaximumSumAverage)
             double d;
 
             // Those that have criterias include all rows, also those with null
-            d = table1->where().average_int(c0);
+            d = table1->where().avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = table1->where().average_int(c1);
+            d = table1->where().avg(c1)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
             // Criteria on same column as average
-            d = table1->where().not_equal(c0, 1234).average_int(c0);
+            d = table1->where().not_equal(c0, 1234).avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
             // Criteria on other column than average (triggers different code paths)
-            d = table1->where().not_equal(c0, 1234).average_int(c1);
+            d = table1->where().not_equal(c0, 1234).avg(c1)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
             // Average of double, criteria on integer
-            d = table1->where().not_equal(c0, 1234).average_double(c2);
+            d = table1->where().not_equal(c0, 1234).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = table1->where().not_equal(c2, 1234.).average_double(c2);
+            d = table1->where().not_equal(c2, 1234.).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = (table1->column<Int>(c0) == null()).average_int(c0);
-            CHECK_EQUAL(d, 0);
+            CHECK((table1->column<Int>(c0) == null()).avg(c0)->is_null());
 
-            d = (table1->column<Int>(c0) != null()).average_int(c0);
+            d = (table1->column<Int>(c0) != null()).avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
             // Those with criteria now only include some rows, whereof none are null
-            d = table1->where().average_int(c0);
+            d = table1->where().avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = table1->where().average_int(c1);
+            d = table1->where().avg(c1)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
             // Criteria on same column as average
-            d = table1->where().equal(c0, 3).average_int(c0);
+            d = table1->where().equal(c0, 3).avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 3., 0.001);
 
             // Criteria on other column than average (triggers different code paths)
-            d = table1->where().equal(c0, 3).average_int(c1);
+            d = table1->where().equal(c0, 3).avg(c1)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 3., 0.001);
 
             // Average of double, criteria on integer
-            d = table1->where().not_equal(c0, 3).average_double(c2);
+            d = table1->where().not_equal(c0, 3).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 4., 0.001);
 
-            d = table1->where().equal(c2, 3.).average_double(c2);
+            d = table1->where().equal(c2, 3.).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 3., 0.001);
 
             // Now using null as criteria
-            d = (table1->column<Int>(c0) != null()).average_double(c2);
+            d = (table1->column<Int>(c0) != null()).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = (table1->column<Double>(c2) != null()).average_double(c2);
+            d = (table1->column<Double>(c2) != null()).avg(c2)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = (table1->column<Int>(c0) != null()).average_int(c0);
+            d = (table1->column<Int>(c0) != null()).avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
 
-            d = (table1->column<Int>(c1) != null()).average_int(c0);
+            d = (table1->column<Int>(c1) != null()).avg(c0)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, 7. / 2., 0.001);
         }
 
 
         // Maximum
         {
-            int64_t d;
-            double dbl;
+            std::optional<Mixed> m;
             // Those that have criterias include all rows, also those with null
-            d = table1->where().maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().max(c0);
+            CHECK_EQUAL(m, 4);
 
-            d = table1->where().maximum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().max(c1);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on same column as maximum
-            d = table1->where().not_equal(c0, 1234).maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().not_equal(c0, 1234).max(c0);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on other column than maximum (triggers different code paths)
-            d = table1->where().not_equal(c0, 1234).maximum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().not_equal(c0, 1234).max(c1);
+            CHECK_EQUAL(m, 4);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 1234).maximum_double(c2);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().not_equal(c0, 1234).max(c2);
+            CHECK_EQUAL(m, 4);
 
-            dbl = table1->where().not_equal(c2, 1234.).maximum_double(c2);
-            CHECK_EQUAL(d, 4.);
+            m = table1->where().not_equal(c2, 1234.).max(c2);
+            CHECK_EQUAL(m, 4.);
 
             // Those with criteria now only include some rows, whereof none are null
-            d = table1->where().maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().max(c0);
+            CHECK_EQUAL(m, 4);
 
-            d = table1->where().maximum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().max(c1);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on same column as maximum
-            d = table1->where().equal(c0, 4).maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).max(c0);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on other column than maximum (triggers different code paths)
-            d = table1->where().equal(c0, 4).maximum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).max(c1);
+            CHECK_EQUAL(m, 4);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 3).maximum_double(c2);
-            CHECK_EQUAL(dbl, 4.);
+            m = table1->where().not_equal(c0, 3).max(c2);
+            CHECK_EQUAL(m, 4.);
 
-            dbl = table1->where().equal(c2, 3.).maximum_double(c2);
-            CHECK_EQUAL(dbl, 3.);
+            m = table1->where().equal(c2, 3.).max(c2);
+            CHECK_EQUAL(m, 3.);
 
             // Now using null as criteria
-            dbl = (table1->column<Int>(c0) != null()).maximum_double(c2);
-            CHECK_EQUAL(dbl, 4.);
+            m = (table1->column<Int>(c0) != null()).max(c2);
+            CHECK_EQUAL(m, 4.);
 
-            dbl = (table1->column<Double>(c2) != null()).maximum_double(c2);
-            CHECK_EQUAL(dbl, 4.);
+            m = (table1->column<Double>(c2) != null()).max(c2);
+            CHECK_EQUAL(m, 4.);
 
-            d = (table1->column<Int>(c0) != null()).maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = (table1->column<Int>(c0) != null()).max(c0);
+            CHECK_EQUAL(m, 4);
 
-            d = (table1->column<Int>(c1) != null()).maximum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = (table1->column<Int>(c1) != null()).max(c0);
+            CHECK_EQUAL(m, 4);
         }
 
 
         // Minimum
         {
-            int64_t d;
-            double dbl;
+            std::optional<Mixed> m;
             // Those that have criterias include all rows, also those with null
-            d = table1->where().minimum_int(c0);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().min(c0);
+            CHECK_EQUAL(m, 3);
 
-            d = table1->where().minimum_int(c1);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().min(c1);
+            CHECK_EQUAL(m, 3);
 
             // Criteria on same column as minimum
-            d = table1->where().not_equal(c0, 1234).minimum_int(c0);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().not_equal(c0, 1234).min(c0);
+            CHECK_EQUAL(m, 3);
 
             // Criteria on other column than minimum (triggers different code paths)
-            d = table1->where().not_equal(c0, 1234).minimum_int(c1);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().not_equal(c0, 1234).min(c1);
+            CHECK_EQUAL(m, 3);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 1234).minimum_double(c2);
-            CHECK_EQUAL(dbl, 3);
+            m = table1->where().not_equal(c0, 1234).min(c2);
+            CHECK_EQUAL(m, 3);
 
-            dbl = table1->where().not_equal(c2, 1234.).minimum_double(c2);
-            CHECK_EQUAL(dbl, 3.);
+            m = table1->where().not_equal(c2, 1234.).min(c2);
+            CHECK_EQUAL(m, 3.);
 
 
             // Those with criteria now only include some rows, whereof none are null
-            d = table1->where().minimum_int(c0);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().min(c0);
+            CHECK_EQUAL(m, 3);
 
-            d = table1->where().minimum_int(c1);
-            CHECK_EQUAL(d, 3);
+            m = table1->where().min(c1);
+            CHECK_EQUAL(m, 3);
 
             // Criteria on same column as minimum
-            d = table1->where().equal(c0, 4).minimum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).min(c0);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on other column than minimum (triggers different code paths)
-            d = table1->where().equal(c0, 4).minimum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).min(c1);
+            CHECK_EQUAL(m, 4);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 3).minimum_double(c2);
-            CHECK_EQUAL(dbl, 4.);
+            m = table1->where().not_equal(c0, 3).min(c2);
+            CHECK_EQUAL(m, 4.);
 
-            dbl = table1->where().equal(c2, 3.).minimum_double(c2);
-            CHECK_EQUAL(dbl, 3.);
+            m = table1->where().equal(c2, 3.).min(c2);
+            CHECK_EQUAL(m, 3.);
 
             // Now using null as criteria
-            dbl = (table1->column<Int>(c0) != null()).minimum_double(c2);
-            CHECK_EQUAL(dbl, 3.);
+            m = (table1->column<Int>(c0) != null()).min(c2);
+            CHECK_EQUAL(m, 3.);
 
-            dbl = (table1->column<Double>(c2) != null()).minimum_double(c2);
-            CHECK_EQUAL(dbl, 3.);
+            m = (table1->column<Double>(c2) != null()).min(c2);
+            CHECK_EQUAL(m, 3.);
 
-            d = (table1->column<Int>(c0) != null()).minimum_int(c0);
-            CHECK_EQUAL(d, 3);
+            m = (table1->column<Int>(c0) != null()).min(c0);
+            CHECK_EQUAL(m, 3);
 
-            d = (table1->column<Int>(c1) != null()).minimum_int(c0);
-            CHECK_EQUAL(d, 3);
+            m = (table1->column<Int>(c1) != null()).min(c0);
+            CHECK_EQUAL(m, 3);
         }
 
         // Sum
         {
-            int64_t d;
-            double dbl;
+            std::optional<Mixed> m;
             // Those that have criterias include all rows, also those with null
-            d = table1->where().sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = table1->where().sum(c0);
+            CHECK_EQUAL(m, 7);
 
             // Criteria on same column as maximum
-            d = table1->where().not_equal(c0, 1234).sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = table1->where().not_equal(c0, 1234).sum(c0);
+            CHECK_EQUAL(m, 7);
 
             // Criteria on other column than maximum (triggers different code paths)
-            d = table1->where().not_equal(c0, 1234).sum_int(c1);
-            CHECK_EQUAL(d, 7);
+            m = table1->where().not_equal(c0, 1234).sum(c1);
+            CHECK_EQUAL(m, 7);
 
-            d = (table1->column<Int>(c0) == null()).sum_int(c0);
-            CHECK_EQUAL(d, 0);
+            m = (table1->column<Int>(c0) == null()).sum(c0);
+            CHECK_EQUAL(m, 0);
 
-            d = (table1->column<Int>(c0) != null()).sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = (table1->column<Int>(c0) != null()).sum(c0);
+            CHECK_EQUAL(m, 7);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 1234).sum_double(c2);
-            CHECK_EQUAL(dbl, 7.);
+            m = table1->where().not_equal(c0, 1234).sum(c2);
+            CHECK_EQUAL(m, 7.);
 
-            dbl = table1->where().not_equal(c2, 1234.).sum_double(c2);
-            CHECK_APPROXIMATELY_EQUAL(dbl, 7., 0.001);
+            m = table1->where().not_equal(c2, 1234.).sum(c2);
+            CHECK_APPROXIMATELY_EQUAL(m->get_double(), 7., 0.001);
 
 
             // Those with criteria now only include some rows, whereof none are null
-            d = table1->where().sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = table1->where().sum(c0);
+            CHECK_EQUAL(m, 7);
 
-            d = table1->where().sum_int(c1);
-            CHECK_EQUAL(d, 7);
+            m = table1->where().sum(c1);
+            CHECK_EQUAL(m, 7);
 
             // Criteria on same column as maximum
-            d = table1->where().equal(c0, 4).sum_int(c0);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).sum(c0);
+            CHECK_EQUAL(m, 4);
 
             // Criteria on other column than maximum (triggers different code paths)
-            d = table1->where().equal(c0, 4).sum_int(c1);
-            CHECK_EQUAL(d, 4);
+            m = table1->where().equal(c0, 4).sum(c1);
+            CHECK_EQUAL(m, 4);
 
             // Average of double, criteria on integer
-            dbl = table1->where().not_equal(c0, 3).sum_double(c2);
-            CHECK_APPROXIMATELY_EQUAL(dbl, 4., 0.001);
+            m = table1->where().not_equal(c0, 3).sum(c2);
+            CHECK_APPROXIMATELY_EQUAL(m->get_double(), 4., 0.001);
 
-            dbl = table1->where().equal(c2, 3.).sum_double(c2);
-            CHECK_APPROXIMATELY_EQUAL(dbl, 3., 0.001);
+            m = table1->where().equal(c2, 3.).sum(c2);
+            CHECK_APPROXIMATELY_EQUAL(m->get_double(), 3., 0.001);
 
             // Now using null as criteria
-            dbl = (table1->column<Int>(c0) != null()).sum_double(c2);
-            CHECK_APPROXIMATELY_EQUAL(dbl, 7., 0.001);
+            m = (table1->column<Int>(c0) != null()).sum(c2);
+            CHECK_APPROXIMATELY_EQUAL(m->get_double(), 7., 0.001);
 
-            dbl = (table1->column<Double>(c2) != null()).sum_double(c2);
-            CHECK_APPROXIMATELY_EQUAL(dbl, 7., 0.001);
+            m = (table1->column<Double>(c2) != null()).sum(c2);
+            CHECK_APPROXIMATELY_EQUAL(m->get_double(), 7., 0.001);
 
-            d = (table1->column<Int>(c0) != null()).sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = (table1->column<Int>(c0) != null()).sum(c0);
+            CHECK_EQUAL(m, 7);
 
-            d = (table1->column<Int>(c1) != null()).sum_int(c0);
-            CHECK_EQUAL(d, 7);
+            m = (table1->column<Int>(c1) != null()).sum(c0);
+            CHECK_EQUAL(m, 7);
         }
 
 
@@ -3781,15 +3775,15 @@ TEST(Query_ReferDeletedLinkView)
     // See if "Query that depends on LinkView" returns sane "empty"-like values
     CHECK_EQUAL(q.find_all().size(), 0);
     CHECK_EQUAL(q.find(), null_key);
-    CHECK_EQUAL(q.sum_int(col_int), 0);
+    CHECK_EQUAL(q.sum(col_int), 0);
     CHECK_EQUAL(q.count(), 0);
     size_t rows;
-    q.average_int(col_int, &rows);
+    q.avg(col_int, &rows);
     CHECK_EQUAL(rows, 0);
 
     tv_sorted.sync_if_needed();
     // See if "TableView that depends on LinkView" returns sane "empty"-like values
-    tv_sorted.average_int(col_int, &rows);
+    tv_sorted.avg(col_int, &rows);
     CHECK_EQUAL(rows, 0);
 
     // Now check a "Query that depends on (TableView that depends on LinkView)"
diff --git a/test/test_table.cpp b/test/test_table.cpp
index 5f6e7ffb3f3..e4b2b8e1702 100644
--- a/test/test_table.cpp
+++ b/test/test_table.cpp
@@ -440,8 +440,8 @@ TEST(Table_DateTimeMinMax)
     objs[1].set(col, Timestamp{0, 0});
     objs[2].set(col, Timestamp{2, 2});
 
-    CHECK_EQUAL(table->maximum_timestamp(col), Timestamp(2, 2));
-    CHECK_EQUAL(table->minimum_timestamp(col), Timestamp(0, 0));
+    CHECK_EQUAL(table->max(col)->get_timestamp(), Timestamp(2, 2));
+    CHECK_EQUAL(table->min(col)->get_timestamp(), Timestamp(0, 0));
 
     objs[0].set(col, Timestamp{0, 0});
     objs[1].set_null(col);
@@ -449,25 +449,25 @@ TEST(Table_DateTimeMinMax)
 
     ObjKey idx; // tableview entry that points at the max/min value
 
-    CHECK_EQUAL(table->maximum_timestamp(col, &idx), Timestamp(2, 2));
+    CHECK_EQUAL(table->max(col, &idx)->get_timestamp(), Timestamp(2, 2));
     CHECK_EQUAL(idx, objs[2].get_key());
-    CHECK_EQUAL(table->minimum_timestamp(col, &idx), Timestamp(0, 0));
+    CHECK_EQUAL(table->min(col, &idx)->get_timestamp(), Timestamp(0, 0));
     CHECK_EQUAL(idx, objs[0].get_key());
 
     objs[0].set_null(col);
     objs[1].set(col, Timestamp{2, 2});
     objs[2].set(col, Timestamp{0, 0});
 
-    CHECK_EQUAL(table->maximum_timestamp(col), Timestamp(2, 2));
-    CHECK_EQUAL(table->minimum_timestamp(col), Timestamp(0, 0));
+    CHECK_EQUAL(table->max(col)->get_timestamp(), Timestamp(2, 2));
+    CHECK_EQUAL(table->min(col)->get_timestamp(), Timestamp(0, 0));
 
     objs[0].set(col, Timestamp{2, 2});
     objs[1].set_null(col);
     objs[2].set(col, Timestamp{0, 0});
 
-    CHECK_EQUAL(table->maximum_timestamp(col, &idx), Timestamp(2, 2));
+    CHECK_EQUAL(table->max(col, &idx)->get_timestamp(), Timestamp(2, 2));
     CHECK_EQUAL(idx, objs[0].get_key());
-    CHECK_EQUAL(table->minimum_timestamp(col, &idx), Timestamp(0, 0));
+    CHECK_EQUAL(table->min(col, &idx)->get_timestamp(), Timestamp(0, 0));
     CHECK_EQUAL(idx, objs[2].get_key());
 }
 
@@ -485,70 +485,67 @@ TEST(Table_MinMaxSingleNullRow)
 
     ObjKey key;
 
-    // NOTE: Return-values of method calls are undefined if you have only null-entries in the table.
-    // The return-value is not necessarily a null-object. Always test the return_ndx argument!
-
     // Maximum
     {
-        table->maximum_timestamp(date_col, &key); // max on table
+        table->max(date_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().maximum_timestamp(date_col, &key); // max on tableview
+        table->where().find_all().max(date_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().maximum_timestamp(date_col, &key); // max on query
+        table->where().max(date_col, &key); // max on query
         CHECK(key == null_key);
 
-        table->maximum_int(int_col, &key); // max on table
+        table->max(int_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().maximum_int(int_col, &key); // max on tableview
+        table->where().find_all().max(int_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().maximum_int(int_col, &key); // max on query
+        table->where().max(int_col, &key); // max on query
         CHECK(key == null_key);
 
-        table->maximum_float(float_col, &key); // max on table
+        table->max(float_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().maximum_float(float_col, &key); // max on tableview
+        table->where().find_all().max(float_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().maximum_float(float_col, &key); // max on query
+        table->where().max(float_col, &key); // max on query
         CHECK(key == null_key);
 
         table->create_object();
 
-        CHECK(table->maximum_timestamp(date_col).is_null());         // max on table
-        table->where().find_all().maximum_timestamp(date_col, &key); // max on tableview
+        CHECK(table->max(date_col)->is_null());        // max on table
+        table->where().find_all().max(date_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().maximum_timestamp(date_col, &key); // max on query
+        table->where().max(date_col, &key); // max on query
         CHECK(key == null_key);
     }
 
     // Minimum
     {
-        table->minimum_timestamp(date_col, &key); // max on table
+        table->min(date_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().minimum_timestamp(date_col, &key); // max on tableview
+        table->where().find_all().min(date_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().minimum_timestamp(date_col, &key); // max on query
+        table->where().min(date_col, &key); // max on query
         CHECK(key == null_key);
 
-        table->minimum_int(int_col, &key); // max on table
+        table->min(int_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().minimum_int(int_col, &key); // max on tableview
+        table->where().find_all().min(int_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().minimum_int(int_col, &key); // max on query
+        table->where().min(int_col, &key); // max on query
         CHECK(key == null_key);
 
-        table->minimum_float(float_col, &key); // max on table
+        table->min(float_col, &key); // max on table
         CHECK(key == null_key);
-        table->where().find_all().minimum_float(float_col, &key); // max on tableview
+        table->where().find_all().min(float_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().minimum_float(float_col, &key); // max on query
+        table->where().min(float_col, &key); // max on query
         CHECK(key == null_key);
 
         table->create_object();
 
-        CHECK(table->minimum_timestamp(date_col).is_null());         // max on table
-        table->where().find_all().minimum_timestamp(date_col, &key); // max on tableview
+        CHECK(table->min(date_col)->is_null());        // max on table
+        table->where().find_all().min(date_col, &key); // max on tableview
         CHECK(key == null_key);
-        table->where().minimum_timestamp(date_col, &key); // max on query
+        table->where().min(date_col, &key); // max on query
         CHECK(key == null_key);
     }
 }
@@ -569,47 +566,48 @@ TEST(TableView_AggregateBugs)
 
         auto tv = table.where().not_equal(int_col, 42).find_all();
         CHECK_EQUAL(tv.size(), 3);
-        CHECK_EQUAL(tv.maximum_int(int_col), 2);
+        CHECK_EQUAL(tv.max(int_col), 2);
 
         // average == sum / rows, where rows does *not* include values with null.
         size_t vc; // number of non-null values that the average was computed from
-        CHECK_APPROXIMATELY_EQUAL(table.average_int(int_col, &vc), double(1 + 2 + 42) / 3, 0.001);
+        CHECK_APPROXIMATELY_EQUAL(table.avg(int_col, &vc)->get_double(), double(1 + 2 + 42) / 3, 0.001);
         CHECK_EQUAL(vc, 3);
 
         // There are currently 3 ways of doing average: on tableview, table and query:
-        CHECK_EQUAL(table.average_int(int_col), table.where().average_int(int_col, &vc));
+        CHECK_EQUAL(table.avg(int_col)->get_double(), table.where().avg(int_col, &vc)->get_double());
         CHECK_EQUAL(vc, 3);
-        CHECK_EQUAL(table.average_int(int_col), table.where().find_all().average_int(int_col, &vc));
+        CHECK_EQUAL(table.avg(int_col)->get_double(), table.where().find_all().avg(int_col, &vc)->get_double());
         CHECK_EQUAL(vc, 3);
 
         // Core has an optimization where it executes average directly on the column if there
         // are no query conditions. Bypass that here.
-        CHECK_APPROXIMATELY_EQUAL(table.where().not_equal(int_col, 1).find_all().average_int(int_col, &vc),
+        CHECK_APPROXIMATELY_EQUAL(table.where().not_equal(int_col, 1).find_all().avg(int_col, &vc)->get_double(),
                                   double(2 + 42) / 2, 0.001);
         CHECK_EQUAL(vc, 2);
 
         // Now doubles
         tv = table.where().not_equal(double_col, 42.).find_all();
         CHECK_EQUAL(tv.size(), 3);
-        CHECK_EQUAL(tv.maximum_double(double_col), 2.);
+        CHECK_EQUAL(tv.max(double_col), 2.);
 
         // average == sum / rows, where rows does *not* include values with null.
-        CHECK_APPROXIMATELY_EQUAL(table.average_double(double_col, &vc), double(1. + 2. + 42.) / 3, 0.001);
+        CHECK_APPROXIMATELY_EQUAL(table.avg(double_col, &vc)->get_double(), double(1. + 2. + 42.) / 3, 0.001);
         CHECK_EQUAL(vc, 3);
 
         // There are currently 3 ways of doing average: on tableview, table and query:
-        CHECK_APPROXIMATELY_EQUAL(table.average_double(double_col), table.where().average_double(double_col, &vc),
-                                  0.001);
+        CHECK_APPROXIMATELY_EQUAL(table.avg(double_col)->get_double(),
+                                  table.where().avg(double_col, &vc)->get_double(), 0.001);
         CHECK_EQUAL(vc, 3);
 
-        CHECK_APPROXIMATELY_EQUAL(table.average_double(double_col),
-                                  table.where().find_all().average_double(double_col, &vc), 0.001);
+        CHECK_APPROXIMATELY_EQUAL(table.avg(double_col)->get_double(),
+                                  table.where().find_all().avg(double_col, &vc)->get_double(), 0.001);
         CHECK_EQUAL(vc, 3);
 
         // Core has an optimization where it executes average directly on the column if there
         // are no query conditions. Bypass that here.
-        CHECK_APPROXIMATELY_EQUAL(table.where().not_equal(double_col, 1.).find_all().average_double(double_col, &vc),
-                                  (2. + 42.) / 2, 0.001);
+        CHECK_APPROXIMATELY_EQUAL(
+            table.where().not_equal(double_col, 1.).find_all().avg(double_col, &vc)->get_double(), (2. + 42.) / 2,
+            0.001);
         CHECK_EQUAL(vc, 2);
     }
 
@@ -625,18 +623,18 @@ TEST(TableView_AggregateBugs)
 
         auto tv = table.where().not_equal(int_col, 42).find_all();
         CHECK_EQUAL(tv.size(), 3);
-        CHECK_EQUAL(tv.maximum_int(int_col), 2);
+        CHECK_EQUAL(tv.max(int_col), 2);
 
         // average == sum / rows, where rows does *not* include values with null.
-        CHECK_APPROXIMATELY_EQUAL(table.average_int(int_col), double(1 + 2 + 42) / 3, 0.001);
+        CHECK_APPROXIMATELY_EQUAL(table.avg(int_col)->get_double(), double(1 + 2 + 42) / 3, 0.001);
 
         // There are currently 3 ways of doing average: on tableview, table and query:
-        CHECK_EQUAL(table.average_int(int_col), table.where().average_int(int_col));
-        CHECK_EQUAL(table.average_int(int_col), table.where().find_all().average_int(int_col));
+        CHECK_EQUAL(table.avg(int_col)->get_double(), table.where().avg(int_col)->get_double());
+        CHECK_EQUAL(table.avg(int_col)->get_double(), table.where().find_all().avg(int_col)->get_double());
 
         // Core has an optimization where it executes average directly on the column if there
         // are no query conditions. Bypass that here.
-        CHECK_APPROXIMATELY_EQUAL(table.where().not_equal(int_col, 1).find_all().average_int(int_col),
+        CHECK_APPROXIMATELY_EQUAL(table.where().not_equal(int_col, 1).find_all().avg(int_col)->get_double(),
                                   double(2 + 42) / 2, 0.001);
     }
 }
@@ -690,49 +688,49 @@ TEST(Table_AggregateFuzz)
 
         ObjKey key;
         size_t cnt;
-        float f;
         int64_t i;
         Timestamp ts;
+        Mixed m;
 
         // Test methods on Table
         {
             // Table::max
             key = ObjKey(123);
-            f = table->maximum_float(float_col, &key);
+            m = *table->max(float_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(largest_pos).get<float>(float_col));
+                CHECK_EQUAL(m.get_float(), table->get_object(largest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->maximum_int(int_col, &key);
+            m = *table->max(int_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m.get_int(), table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            ts = table->maximum_timestamp(date_col, &key);
+            m = *table->max(date_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(largest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m.get_timestamp(), table->get_object(largest_pos).get<Timestamp>(date_col));
 
             // Table::min
             key = ObjKey(123);
-            f = table->minimum_float(float_col, &key);
+            m = *table->min(float_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(smallest_pos).get<float>(float_col));
+                CHECK_EQUAL(m.get_float(), table->get_object(smallest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->minimum_int(int_col, &key);
+            m = *table->min(int_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m.get_int(), table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            ts = table->minimum_timestamp(date_col, &key);
+            m = *table->min(date_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(smallest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m.get_timestamp(), table->get_object(smallest_pos).get<Timestamp>(date_col));
 
             // Table::avg
             double d;
@@ -741,22 +739,22 @@ TEST(Table_AggregateFuzz)
             cnt = 123;
 
             // Table::avg
-            d = table->average_float(float_col, &cnt);
+            m = *table->avg(float_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             cnt = 123;
-            d = table->average_int(int_col, &cnt);
+            m = *table->avg(int_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             // Table::sum
-            d = table->sum_float(float_col);
+            d = table->sum(float_col)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, double(sum), 0.001);
 
-            i = table->sum_int(int_col);
+            i = table->sum(int_col)->get_int();
             CHECK_EQUAL(i, sum);
         }
 
@@ -764,41 +762,41 @@ TEST(Table_AggregateFuzz)
         {
             // TableView::max
             key = ObjKey(123);
-            f = table->where().find_all().maximum_float(float_col, &key);
+            m = *table->where().find_all().max(float_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(largest_pos).get<float>(float_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->where().find_all().maximum_int(int_col, &key);
+            m = *table->where().find_all().max(int_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            ts = table->where().find_all().maximum_timestamp(date_col, &key);
+            m = *table->where().find_all().max(date_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(largest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<Timestamp>(date_col));
 
             // TableView::min
             key = ObjKey(123);
-            f = table->where().find_all().minimum_float(float_col, &key);
+            m = *table->where().find_all().min(float_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(smallest_pos).get<float>(float_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->where().find_all().minimum_int(int_col, &key);
+            m = *table->where().find_all().min(int_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            ts = table->where().find_all().minimum_timestamp(date_col, &key);
+            m = *table->where().find_all().min(date_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(smallest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<Timestamp>(date_col));
 
             // TableView::avg
             double d;
@@ -807,22 +805,22 @@ TEST(Table_AggregateFuzz)
             key = ObjKey(123);
 
             // TableView::avg
-            d = table->where().find_all().average_float(float_col, &cnt);
+            m = *table->where().find_all().avg(float_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             cnt = 123;
-            d = table->where().find_all().average_int(int_col, &cnt);
+            m = *table->where().find_all().avg(int_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             // TableView::sum
-            d = table->where().find_all().sum_float(float_col);
+            d = table->where().find_all().sum(float_col)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, double(sum), 0.001);
 
-            i = table->where().find_all().sum_int(int_col);
+            i = table->where().find_all().sum(int_col)->get_int();
             CHECK_EQUAL(i, sum);
         }
 
@@ -830,43 +828,41 @@ TEST(Table_AggregateFuzz)
         {
             // TableView::max
             key = ObjKey(123);
-            f = table->where().maximum_float(float_col, &key);
+            m = *table->where().max(float_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(largest_pos).get<float>(float_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->where().maximum_int(int_col, &key);
+            m = *table->where().max(int_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            // Note: Method arguments different from metholds on other column types
-            ts = table->where().maximum_timestamp(date_col, &key);
+            m = *table->where().max(date_col, &key);
             CHECK_EQUAL(key, largest_pos);
             if (largest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(largest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m, table->get_object(largest_pos).get<Timestamp>(date_col));
 
             // TableView::min
             key = ObjKey(123);
-            f = table->where().minimum_float(float_col, &key);
+            m = *table->where().min(float_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(f, table->get_object(smallest_pos).get<float>(float_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<float>(float_col));
 
             key = ObjKey(123);
-            i = table->where().minimum_int(int_col, &key);
+            m = *table->where().min(int_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(i, table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<util::Optional<Int>>(int_col));
 
             key = ObjKey(123);
-            // Note: Method arguments different from metholds on other column types
-            ts = table->where().minimum_timestamp(date_col, &key);
+            m = *table->where().min(date_col, &key);
             CHECK_EQUAL(key, smallest_pos);
             if (smallest_pos != null_key)
-                CHECK_EQUAL(ts, table->get_object(smallest_pos).get<Timestamp>(date_col));
+                CHECK_EQUAL(m, table->get_object(smallest_pos).get<Timestamp>(date_col));
 
             // TableView::avg
             double d;
@@ -875,23 +871,23 @@ TEST(Table_AggregateFuzz)
             cnt = 123;
 
             // TableView::avg
-            d = table->where().average_float(float_col, &cnt);
+            m = *table->where().avg(float_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             cnt = 123;
-            d = table->where().average_int(int_col, &cnt);
+            m = *table->where().avg(int_col, &cnt);
             CHECK_EQUAL(cnt, (rows - nulls));
             if (cnt != 0)
-                CHECK_APPROXIMATELY_EQUAL(d, avg, 0.001);
+                CHECK_APPROXIMATELY_EQUAL(m.get_double(), avg, 0.001);
 
             // TableView::sum
-            d = table->where().sum_float(float_col);
+            d = table->where().sum(float_col)->get_double();
             CHECK_APPROXIMATELY_EQUAL(d, double(sum), 0.001);
 
-            i = table->where().sum_int(int_col);
-            CHECK_EQUAL(i, sum);
+            m = *table->where().sum(int_col);
+            CHECK_EQUAL(m, sum);
         }
     }
 }
@@ -1921,55 +1917,55 @@ TEST(Table_Aggregates)
     CHECK_EQUAL(1, table.count_decimal(decimal_col, Decimal128("1.12e23")));
     ObjKey ret;
     // minimum
-    CHECK_EQUAL(1, table.minimum_int(int_col, &ret));
+    CHECK_EQUAL(1, table.min(int_col, &ret)->get_int());
     CHECK(ret && table.get_object(ret).get<Int>(int_col) == 1);
     ret = ObjKey();
-    CHECK_EQUAL(1.1f, table.minimum_float(float_col, &ret));
+    CHECK_EQUAL(1.1f, table.min(float_col, &ret)->get_float());
     CHECK(ret);
     CHECK_EQUAL(table.get_object(ret).get<Float>(float_col), 1.1f);
     ret = ObjKey();
-    CHECK_EQUAL(1.2, table.minimum_double(double_col, &ret));
+    CHECK_EQUAL(1.2, table.min(double_col, &ret)->get_double());
     CHECK(ret);
     CHECK_EQUAL(table.get_object(ret).get<Double>(double_col), 1.2);
     ret = ObjKey();
-    CHECK_EQUAL(Decimal128(7.7), table.minimum_decimal(decimal_col, &ret));
+    CHECK_EQUAL(Decimal128(7.7), table.min(decimal_col, &ret)->get_decimal());
     CHECK(ret);
     CHECK_EQUAL(table.get_object(ret).get<Decimal128>(decimal_col), Decimal128(7.7));
 
     // maximum
     ret = ObjKey();
-    CHECK_EQUAL(987654321, table.maximum_int(int_col, &ret));
+    CHECK_EQUAL(987654321, table.max(int_col, &ret)->get_int());
     CHECK(ret);
     CHECK_EQUAL(table.get_object(ret).get<Int>(int_col), 987654321);
     ret = ObjKey();
-    CHECK_EQUAL(11.0f, table.maximum_float(float_col, &ret));
+    CHECK_EQUAL(11.0f, table.max(float_col, &ret)->get_float());
     CHECK(ret);
     CHECK_EQUAL(11.0f, table.get_object(ret).get<Float>(float_col));
     ret = ObjKey();
-    CHECK_EQUAL(12.0, table.maximum_double(double_col, &ret));
+    CHECK_EQUAL(12.0, table.max(double_col, &ret)->get_double());
     CHECK(ret);
     CHECK_EQUAL(12.0, table.get_object(ret).get<Double>(double_col));
     ret = ObjKey();
-    CHECK_EQUAL(Decimal128("1.12e23"), table.maximum_decimal(decimal_col, &ret));
+    CHECK_EQUAL(Decimal128("1.12e23"), table.max(decimal_col, &ret)->get_decimal());
     CHECK(ret);
     CHECK_EQUAL(Decimal128("1.12e23"), table.get_object(ret).get<Decimal128>(decimal_col));
     // sum
-    CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.sum_int(int_col)), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(f_sum, table.sum_float(float_col), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(d_sum, table.sum_double(double_col), 10 * epsilon);
-    CHECK_EQUAL(decimal_sum, table.sum_decimal(decimal_col));
+    CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.sum(int_col)->get_int()), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(f_sum, table.sum(float_col)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(d_sum, table.sum(double_col)->get_double(), 10 * epsilon);
+    CHECK_EQUAL(decimal_sum, table.sum(decimal_col)->get_decimal());
     // average
     size_t count = realm::npos;
-    CHECK_APPROXIMATELY_EQUAL(i_sum / size, table.average_int(int_col, &count), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(i_sum / size, table.avg(int_col, &count)->get_double(), 10 * epsilon);
     CHECK_EQUAL(count, size);
     count = realm::npos;
-    CHECK_APPROXIMATELY_EQUAL(f_sum / size, table.average_float(float_col, &count), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(f_sum / size, table.avg(float_col, &count)->get_double(), 10 * epsilon);
     CHECK_EQUAL(count, size);
     count = realm::npos;
-    CHECK_APPROXIMATELY_EQUAL(d_sum / size, table.average_double(double_col, &count), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(d_sum / size, table.avg(double_col, &count)->get_double(), 10 * epsilon);
     CHECK_EQUAL(count, size);
     count = realm::npos;
-    CHECK_EQUAL(decimal_sum / Decimal128(size), table.average_decimal(decimal_col, &count));
+    CHECK_EQUAL(decimal_sum / Decimal128(size), table.avg(decimal_col, &count)->get_decimal());
     CHECK_EQUAL(count, size);
 }
 
@@ -1985,9 +1981,9 @@ TEST(Table_Aggregates2)
         c++;
     }
 
-    CHECK_EQUAL(-420, table.minimum_int(int_col));
-    CHECK_EQUAL(-21, table.maximum_int(int_col));
-    CHECK_EQUAL(s, table.sum_int(int_col));
+    CHECK_EQUAL(-420, table.min(int_col)->get_int());
+    CHECK_EQUAL(-21, table.max(int_col)->get_int());
+    CHECK_EQUAL(s, table.sum(int_col)->get_int());
 }
 
 // Test Table methods max, min, avg, sum, on both nullable and non-nullable columns
@@ -2034,120 +2030,120 @@ TEST(Table_Aggregates3)
         if (nullable) {
             // max
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_int(col_price), 3);
-            CHECK_EQUAL(table->maximum_int(col_price, &pos), 3);
+            CHECK_EQUAL(table->max(col_price)->get_int(), 3);
+            CHECK_EQUAL(table->max(col_price, &pos)->get_int(), 3);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_float(col_shipping), 30.f);
-            CHECK_EQUAL(table->maximum_float(col_shipping, &pos), 30.f);
+            CHECK_EQUAL(table->max(col_shipping)->get_float(), 30.f);
+            CHECK_EQUAL(table->max(col_shipping, &pos)->get_float(), 30.f);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_double(col_rating), 2.2);
-            CHECK_EQUAL(table->maximum_double(col_rating, &pos), 2.2);
+            CHECK_EQUAL(table->max(col_rating)->get_double(), 2.2);
+            CHECK_EQUAL(table->max(col_rating, &pos)->get_double(), 2.2);
             CHECK_EQUAL(pos, ObjKey(1));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_timestamp(col_date), Timestamp(6, 6));
-            CHECK_EQUAL(table->maximum_timestamp(col_date, &pos), Timestamp(6, 6));
+            CHECK_EQUAL(table->max(col_date)->get_timestamp(), Timestamp(6, 6));
+            CHECK_EQUAL(table->max(col_date, &pos)->get_timestamp(), Timestamp(6, 6));
             CHECK_EQUAL(pos, ObjKey(2));
 
             // min
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_int(col_price), 1);
-            CHECK_EQUAL(table->minimum_int(col_price, &pos), 1);
+            CHECK_EQUAL(table->min(col_price)->get_int(), 1);
+            CHECK_EQUAL(table->min(col_price, &pos)->get_int(), 1);
             CHECK_EQUAL(pos, ObjKey(0));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_float(col_shipping), 30.f);
-            CHECK_EQUAL(table->minimum_float(col_shipping, &pos), 30.f);
+            CHECK_EQUAL(table->min(col_shipping)->get_float(), 30.f);
+            CHECK_EQUAL(table->min(col_shipping, &pos)->get_float(), 30.f);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_double(col_rating), 1.1);
-            CHECK_EQUAL(table->minimum_double(col_rating, &pos), 1.1);
+            CHECK_EQUAL(table->min(col_rating)->get_double(), 1.1);
+            CHECK_EQUAL(table->min(col_rating, &pos)->get_double(), 1.1);
             CHECK_EQUAL(pos, ObjKey(0));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_timestamp(col_date), Timestamp(2, 2));
-            CHECK_EQUAL(table->minimum_timestamp(col_date, &pos), Timestamp(2, 2));
+            CHECK_EQUAL(table->min(col_date)->get_timestamp(), Timestamp(2, 2));
+            CHECK_EQUAL(table->min(col_date, &pos)->get_timestamp(), Timestamp(2, 2));
             CHECK_EQUAL(pos, ObjKey(0));
 
             // average
             count = 123;
-            CHECK_APPROXIMATELY_EQUAL(table->average_int(col_price), (1 + 3) / 2., 0.01);
-            CHECK_APPROXIMATELY_EQUAL(table->average_int(col_price, &count), (1 + 3) / 2., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_price)->get_double(), (1 + 3) / 2., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_price, &count)->get_double(), (1 + 3) / 2., 0.01);
             CHECK_EQUAL(count, 2);
 
             count = 123;
-            CHECK_EQUAL(table->average_float(col_shipping), 30.f);
-            CHECK_EQUAL(table->average_float(col_shipping, &count), 30.f);
+            CHECK_EQUAL(table->avg(col_shipping)->get_double(), 30.f);
+            CHECK_EQUAL(table->avg(col_shipping, &count)->get_double(), 30.f);
             CHECK_EQUAL(count, 1);
 
             count = 123;
-            CHECK_APPROXIMATELY_EQUAL(table->average_double(col_rating), (1.1 + 2.2) / 2., 0.01);
-            CHECK_APPROXIMATELY_EQUAL(table->average_double(col_rating, &count), (1.1 + 2.2) / 2., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_rating)->get_double(), (1.1 + 2.2) / 2., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_rating, &count)->get_double(), (1.1 + 2.2) / 2., 0.01);
             CHECK_EQUAL(count, 2);
 
             // sum
-            CHECK_EQUAL(table->sum_int(col_price), 4);
-            CHECK_EQUAL(table->sum_float(col_shipping), 30.f);
-            CHECK_APPROXIMATELY_EQUAL(table->sum_double(col_rating), 1.1 + 2.2, 0.01);
+            CHECK_EQUAL(table->sum(col_price)->get_int(), 4);
+            CHECK_EQUAL(table->sum(col_shipping)->get_double(), 30.f);
+            CHECK_APPROXIMATELY_EQUAL(table->sum(col_rating)->get_double(), 1.1 + 2.2, 0.01);
         }
         else { // not nullable
             // max
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_int(col_price, &pos), 3);
+            CHECK_EQUAL(table->max(col_price, &pos)->get_int(), 3);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_float(col_shipping, &pos), 30.f);
+            CHECK_EQUAL(table->max(col_shipping, &pos)->get_float(), 30.f);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_double(col_rating, &pos), 2.2);
+            CHECK_EQUAL(table->max(col_rating, &pos)->get_double(), 2.2);
             CHECK_EQUAL(pos, ObjKey(1));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->maximum_timestamp(col_date, &pos), Timestamp(6, 6));
+            CHECK_EQUAL(table->max(col_date, &pos)->get_timestamp(), Timestamp(6, 6));
             CHECK_EQUAL(pos, ObjKey(2));
 
             // min
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_int(col_price, &pos), 0);
+            CHECK_EQUAL(table->min(col_price, &pos)->get_int(), 0);
             CHECK_EQUAL(pos, ObjKey(1));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_float(col_shipping, &pos), 0.f);
+            CHECK_EQUAL(table->min(col_shipping, &pos)->get_float(), 0.f);
             CHECK_EQUAL(pos, ObjKey(0));
 
             pos = ObjKey(123);
-            CHECK_EQUAL(table->minimum_double(col_rating, &pos), 0.);
+            CHECK_EQUAL(table->min(col_rating, &pos)->get_double(), 0.);
             CHECK_EQUAL(pos, ObjKey(2));
 
             pos = ObjKey(123);
             // Timestamp(0, 0) is default value for non-nullable column
-            CHECK_EQUAL(table->minimum_timestamp(col_date, &pos), Timestamp(0, 0));
+            CHECK_EQUAL(table->min(col_date, &pos)->get_timestamp(), Timestamp(0, 0));
             CHECK_EQUAL(pos, ObjKey(1));
 
             // average
             count = 123;
-            CHECK_APPROXIMATELY_EQUAL(table->average_int(col_price, &count), (1 + 3 + 0) / 3., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_price, &count)->get_double(), (1 + 3 + 0) / 3., 0.01);
             CHECK_EQUAL(count, 3);
 
             count = 123;
-            CHECK_APPROXIMATELY_EQUAL(table->average_float(col_shipping, &count), 30.f / 3., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_shipping, &count)->get_double(), 30.f / 3., 0.01);
             CHECK_EQUAL(count, 3);
 
             count = 123;
-            CHECK_APPROXIMATELY_EQUAL(table->average_double(col_rating, &count), (1.1 + 2.2 + 0.) / 3., 0.01);
+            CHECK_APPROXIMATELY_EQUAL(table->avg(col_rating, &count)->get_double(), (1.1 + 2.2 + 0.) / 3., 0.01);
             CHECK_EQUAL(count, 3);
 
             // sum
-            CHECK_EQUAL(table->sum_int(col_price), 4);
-            CHECK_EQUAL(table->sum_float(col_shipping), 30.f);
-            CHECK_APPROXIMATELY_EQUAL(table->sum_double(col_rating), 1.1 + 2.2, 0.01);
+            CHECK_EQUAL(table->sum(col_price)->get_int(), 4);
+            CHECK_EQUAL(table->sum(col_shipping)->get_double(), 30.f);
+            CHECK_APPROXIMATELY_EQUAL(table->sum(col_rating)->get_double(), 1.1 + 2.2, 0.01);
         }
     }
 }
@@ -2159,14 +2155,14 @@ TEST(Table_EmptyMinmax)
     auto col = table->add_column(type_Timestamp, "date");
 
     ObjKey min_key;
-    Timestamp min_ts = table->minimum_timestamp(col, &min_key);
+    bool is_null = table->min(col, &min_key)->is_null();
     CHECK_EQUAL(min_key, null_key);
-    CHECK(min_ts.is_null());
+    CHECK(is_null);
 
     ObjKey max_key;
-    Timestamp max_ts = table->maximum_timestamp(col, &max_key);
+    is_null = table->max(col, &max_key)->is_null();
     CHECK_EQUAL(max_key, null_key);
-    CHECK(max_ts.is_null());
+    CHECK(is_null);
 }
 
 TEST(Table_EnumStringInsertEmptyRow)
@@ -2410,10 +2406,10 @@ TEST(Table_Nulls)
         CHECK_EQUAL(false, obj0.get<Bool>(col_bool));
         CHECK_EQUAL(Timestamp(3, 0), obj0.get<Timestamp>(col_date));
 
-        CHECK_EQUAL(65, t.maximum_int(col_int));
-        CHECK_EQUAL(65, t.minimum_int(col_int));
-        CHECK_EQUAL(Timestamp(3, 0), t.maximum_timestamp(col_date));
-        CHECK_EQUAL(Timestamp(3, 0), t.minimum_timestamp(col_date));
+        CHECK_EQUAL(65, t.max(col_int)->get_int());
+        CHECK_EQUAL(65, t.min(col_int)->get_int());
+        CHECK_EQUAL(Timestamp(3, 0), t.max(col_date)->get_timestamp());
+        CHECK_EQUAL(Timestamp(3, 0), t.min(col_date)->get_timestamp());
 
         CHECK_NOT(obj0.is_null(col_int));
         CHECK_NOT(obj0.is_null(col_bool));
@@ -2459,10 +2455,10 @@ TEST(Table_Nulls)
         CHECK_EQUAL(1.23f, obj0.get<float>(col_float));
         CHECK_EQUAL(12.3, obj0.get<double>(col_double));
 
-        CHECK_EQUAL(1.23f, t.maximum_float(col_float));
-        CHECK_EQUAL(1.23f, t.minimum_float(col_float));
-        CHECK_EQUAL(12.3, t.maximum_double(col_double));
-        CHECK_EQUAL(12.3, t.minimum_double(col_double));
+        CHECK_EQUAL(1.23f, t.max(col_float)->get_float());
+        CHECK_EQUAL(1.23f, t.min(col_float)->get_float());
+        CHECK_EQUAL(12.3, t.max(col_double)->get_double());
+        CHECK_EQUAL(12.3, t.min(col_double)->get_double());
 
         CHECK_NOT(obj0.is_null(col_float));
         CHECK_NOT(obj0.is_null(col_double));
diff --git a/test/test_table_view.cpp b/test/test_table_view.cpp
index 39f76260b46..b1c398e7f61 100644
--- a/test/test_table_view.cpp
+++ b/test/test_table_view.cpp
@@ -94,17 +94,17 @@ TEST(TableView_TimestampMaxMinCount)
     t.create_object();
 
     TableView tv = t.where().find_all();
-    Timestamp ts;
+    std::optional<Mixed> ts;
 
-    ts = tv.maximum_timestamp(col, nullptr);
+    ts = tv.max(col, nullptr);
     CHECK_EQUAL(ts, Timestamp(300, 300));
-    ts = tv.minimum_timestamp(col, nullptr);
+    ts = tv.min(col, nullptr);
     CHECK_EQUAL(ts, Timestamp(100, 100));
 
     ObjKey key;
-    ts = tv.maximum_timestamp(col, &key);
+    ts = tv.max(col, &key);
     CHECK_EQUAL(key, max_key);
-    ts = tv.minimum_timestamp(col, &key);
+    ts = tv.min(col, &key);
     CHECK_EQUAL(key, min_key);
 
     size_t cnt;
@@ -159,55 +159,55 @@ TEST(TableView_FloatsFindAndAggregations)
     double epsilon = std::numeric_limits<double>::epsilon();
 
     // Test sum
-    CHECK_APPROXIMATELY_EQUAL(sum_d, v_all.sum_double(col_double), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(sum_f, v_all.sum_float(col_float), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(-1.2 + -1.2, v_some.sum_double(col_double), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(double(1.2f) + double(-1.1f), v_some.sum_float(col_float), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum_d, v_all.sum(col_double)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum_f, v_all.sum(col_float)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(-1.2 + -1.2, v_some.sum(col_double)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(double(1.2f) + double(-1.1f), v_some.sum(col_float)->get_double(), 10 * epsilon);
 
     ObjKey key;
 
     // Test max
-    CHECK_EQUAL(3.2, v_all.maximum_double(col_double, &key));
+    CHECK_EQUAL(3.2, v_all.max(col_double, &key)->get_double());
     CHECK_EQUAL(ObjKey(2), key);
 
-    CHECK_EQUAL(-1.2, v_some.maximum_double(col_double, &key));
+    CHECK_EQUAL(-1.2, v_some.max(col_double, &key)->get_double());
     CHECK_EQUAL(ObjKey(0), key);
 
-    CHECK_EQUAL(3.1f, v_all.maximum_float(col_float, &key));
+    CHECK_EQUAL(3.1f, v_all.max(col_float, &key)->get_float());
     CHECK_EQUAL(ObjKey(2), key);
 
-    CHECK_EQUAL(1.2f, v_some.maximum_float(col_float, &key));
+    CHECK_EQUAL(1.2f, v_some.max(col_float, &key)->get_float());
     CHECK_EQUAL(ObjKey(0), key);
 
     // Max without ret_index
-    CHECK_EQUAL(3.2, v_all.maximum_double(col_double));
-    CHECK_EQUAL(-1.2, v_some.maximum_double(col_double));
-    CHECK_EQUAL(3.1f, v_all.maximum_float(col_float));
-    CHECK_EQUAL(1.2f, v_some.maximum_float(col_float));
+    CHECK_EQUAL(3.2, v_all.max(col_double)->get_double());
+    CHECK_EQUAL(-1.2, v_some.max(col_double)->get_double());
+    CHECK_EQUAL(3.1f, v_all.max(col_float)->get_float());
+    CHECK_EQUAL(1.2f, v_some.max(col_float)->get_float());
 
     // Test min
-    CHECK_EQUAL(-1.2, v_all.minimum_double(col_double));
-    CHECK_EQUAL(-1.2, v_some.minimum_double(col_double));
-    CHECK_EQUAL(-1.1f, v_all.minimum_float(col_float));
-    CHECK_EQUAL(-1.1f, v_some.minimum_float(col_float));
+    CHECK_EQUAL(-1.2, v_all.min(col_double)->get_double());
+    CHECK_EQUAL(-1.2, v_some.min(col_double)->get_double());
+    CHECK_EQUAL(-1.1f, v_all.min(col_float)->get_float());
+    CHECK_EQUAL(-1.1f, v_some.min(col_float)->get_float());
     // min with ret_ndx
-    CHECK_EQUAL(-1.2, v_all.minimum_double(col_double, &key));
+    CHECK_EQUAL(-1.2, v_all.min(col_double, &key)->get_double());
     CHECK_EQUAL(ObjKey(0), key);
 
-    CHECK_EQUAL(-1.2, v_some.minimum_double(col_double, &key));
+    CHECK_EQUAL(-1.2, v_some.min(col_double, &key)->get_double());
     CHECK_EQUAL(ObjKey(0), key);
 
-    CHECK_EQUAL(-1.1f, v_all.minimum_float(col_float, &key));
+    CHECK_EQUAL(-1.1f, v_all.min(col_float, &key)->get_float());
     CHECK_EQUAL(ObjKey(3), key);
 
-    CHECK_EQUAL(-1.1f, v_some.minimum_float(col_float, &key));
+    CHECK_EQUAL(-1.1f, v_some.min(col_float, &key)->get_float());
     CHECK_EQUAL(ObjKey(3), key);
 
     // Test avg
-    CHECK_APPROXIMATELY_EQUAL(sum_d / 6.0, v_all.average_double(col_double), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL((-1.2 + -1.2) / 2.0, v_some.average_double(col_double), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL(sum_f / 6.0, v_all.average_float(col_float), 10 * epsilon);
-    CHECK_APPROXIMATELY_EQUAL((double(1.2f) + double(-1.1f)) / 2, v_some.average_float(col_float), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum_d / 6.0, v_all.avg(col_double)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL((-1.2 + -1.2) / 2.0, v_some.avg(col_double)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL(sum_f / 6.0, v_all.avg(col_float)->get_double(), 10 * epsilon);
+    CHECK_APPROXIMATELY_EQUAL((double(1.2f) + double(-1.1f)) / 2, v_some.avg(col_float)->get_double(), 10 * epsilon);
 
     CHECK_EQUAL(1, v_some.count_float(col_float, 1.2f));
     CHECK_EQUAL(2, v_some.count_double(col_double, -1.2));
@@ -232,7 +232,7 @@ TEST(TableView_Sum)
     TableView v = table.find_all_int(c0, 2);
     CHECK_EQUAL(5, v.size());
 
-    int64_t sum = v.sum_int(c0);
+    int64_t sum = v.sum(c0)->get_int();
     CHECK_EQUAL(10, sum);
 }
 
@@ -250,7 +250,7 @@ TEST(TableView_Average)
     TableView v = table.find_all_int(c0, 2);
     CHECK_EQUAL(5, v.size());
 
-    double sum = v.average_int(c0);
+    double sum = v.avg(c0)->get_double();
     CHECK_APPROXIMATELY_EQUAL(2., sum, 0.00001);
 }
 
@@ -267,7 +267,7 @@ TEST(TableView_SumNegative)
     v[0].set<Int>(c0, 11);
     v[2].set<Int>(c0, -20);
 
-    int64_t sum = v.sum_int(c0);
+    int64_t sum = v.sum(c0)->get_int();
     CHECK_EQUAL(-9, sum);
 }
 
@@ -304,7 +304,7 @@ TEST(TableView_Max)
     v[1].set<Int>(c0, 2);
     v[2].set<Int>(c0, 1);
 
-    int64_t max = v.maximum_int(c0);
+    int64_t max = v.max(c0)->get_int();
     CHECK_EQUAL(2, max);
 }
 
@@ -322,7 +322,7 @@ TEST(TableView_Max2)
     v[1].set<Int>(c0, -2);
     v[2].set<Int>(c0, -3);
 
-    int64_t max = v.maximum_int(c0, 0);
+    int64_t max = v.max(c0, 0)->get_int();
     CHECK_EQUAL(-1, max);
 }
 
@@ -341,11 +341,11 @@ TEST(TableView_Min)
     v[1].set<Int>(c0, 2);
     v[2].set<Int>(c0, 1);
 
-    int64_t min = v.minimum_int(c0);
+    int64_t min = v.min(c0)->get_int();
     CHECK_EQUAL(-1, min);
 
     ObjKey key;
-    min = v.minimum_int(c0, &key);
+    min = v.min(c0, &key)->get_int();
     CHECK_EQUAL(-1, min);
     CHECK_EQUAL(v[0].get_key(), key);
 }
@@ -364,11 +364,11 @@ TEST(TableView_Min2)
     v[1].set<Int>(c0, -2);
     v[2].set<Int>(c0, -3);
 
-    int64_t min = v.minimum_int(c0);
+    int64_t min = v.min(c0)->get_int();
     CHECK_EQUAL(-3, min);
 
     ObjKey key;
-    min = v.minimum_int(c0 ,&key);
+    min = v.min(c0, &key)->get_int();
     CHECK_EQUAL(-3, min);
     CHECK_EQUAL(v[2].get_key(), key);
 }
@@ -2763,15 +2763,15 @@ TEST(TableView_TimestampMaxRemoveRow)
 
     TableView tv = table.where().find_all();
     CHECK_EQUAL(tv.size(), 10);
-    CHECK_EQUAL(tv.maximum_timestamp(col_date), Timestamp(9, 0));
+    CHECK_EQUAL(tv.max(col_date)->get_timestamp(), Timestamp(9, 0));
 
     table.remove_object(ObjKey(9));
     CHECK_EQUAL(tv.size(), 10);                            // not changed since sync_if_needed hasn't been called
-    CHECK_EQUAL(tv.maximum_timestamp(col_date), Timestamp(8, 0)); // but aggregate functions skip removed rows
+    CHECK_EQUAL(tv.max(col_date)->get_timestamp(), Timestamp(8, 0)); // but aggregate functions skip removed rows
 
     tv.sync_if_needed();
     CHECK_EQUAL(tv.size(), 9);
-    CHECK_EQUAL(tv.maximum_timestamp(col_date), Timestamp(8, 0));
+    CHECK_EQUAL(tv.max(col_date)->get_timestamp(), Timestamp(8, 0));
 }
 
 TEST(TableView_UpdateQuery)
diff --git a/test/test_transform.cpp b/test/test_transform.cpp
index c1a3d2bf6e5..91cd3a593a0 100644
--- a/test/test_transform.cpp
+++ b/test/test_transform.cpp
@@ -596,7 +596,6 @@ TEST(Transform_MergeInsertSetAndErase)
     });
 
     client_2->transaction([](Peer& client_2) {
-        TableRef t;
         client_2.table("class_t")->remove_object(client_2.table("class_t")->begin());
     });
     synchronize(server.get(), {client_1.get(), client_2.get()});