/*************************************************************************
*
* 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_VIEW_HPP
#define REALM_TABLE_VIEW_HPP
#include <realm/sort_descriptor.hpp>
#include <realm/table.hpp>
#include <realm/util/features.h>
#include <realm/obj_list.hpp>
#include <realm/list.hpp>
#include <realm/set.hpp>
namespace realm {
// Views, tables and synchronization between them:
//
// Views are built through queries against either tables or another view.
// Views may be restricted to only hold entries provided by another view.
// this other view is called the "restricting view".
// Views may be sorted in ascending or descending order of values in one ore more columns.
//
// Views remember the query from which it was originally built.
// Views remember the table from which it was originally built.
// Views remember a restricting view if one was used when it was originally built.
// Views remember the sorting criteria (columns and direction)
//
// A view may be operated in one of two distinct modes: *reflective* and *imperative*.
// Sometimes the term "reactive" is used instead of "reflective" with the same meaning.
//
// Reflective views:
// - A reflective view *always* *reflect* the result of running the query.
// If the underlying tables or tableviews change, the reflective view changes as well.
// A reflective view may need to rerun the query it was generated from, a potentially
// costly operation which happens on demand.
// - It does not matter whether changes are explicitly done within the transaction, or
// occur implicitly as part of advance_read() or promote_to_write().
//
// Imperative views:
// - An imperative view only *initially* holds the result of the query. An imperative
// view *never* reruns the query. To force the view to match it's query (by rerunning it),
// the view must be operated in reflective mode.
// An imperative view can be modified explicitly. References can be added, removed or
// changed.
//
// - In imperative mode, the references in the view tracks movement of the referenced data:
// If you delete an entry which is referenced from a view, said reference is detached,
// not removed.
// - It does not matter whether the delete is done in-line (as part of the current transaction),
// or if it is done implicitly as part of advance_read() or promote_to_write().
//
// The choice between reflective and imperative views might eventually be represented by a
// switch on the tableview, but isn't yet. For now, clients (bindings) must call sync_if_needed()
// to get reflective behavior.
//
// Use cases:
//
// 1. Presenting data
// The first use case (and primary motivator behind the reflective view) is to just track
// and present the state of the database. In this case, the view is operated in reflective
// mode, it is not modified within the transaction, and it is not used to modify data in
// other parts of the database.
//
// 2. Background execution
// This is the second use case. The implicit rerun of the query in our first use case
// may be too costly to be acceptable on the main thread. Instead you want to run the query
// on a worker thread, but display it on the main thread. To achieve this, you need two
// Transactions locked on to the same version of the database. If you have that, you can
// import_copy_of() a view from one transaction to the other. See also db.hpp for more
// information. Technically, you can also import_copy_of into a transaction locked to a
// different version. The imported view will automatically match the importing version.
//
// 3. Iterating a view and changing data
// The third use case (and a motivator behind the imperative view) is when you want
// to make changes to the database in accordance with a query result. Imagine you want to
// find all employees with a salary below a limit and raise their salaries to the limit (pseudocode):
//
// promote_to_write();
// view = table.where().less_than(salary_column,limit).find_all();
// for (size_t i = 0; i < view.size(); ++i) {
// view[i].set(salary_column, limit);
// // add this to get reflective mode: view.sync_if_needed();
// }
// commit_and_continue_as_read();
//
// This is idiomatic imperative code and it works if the view is operated in imperative mode.
//
// If the view is operated in reflective mode, the behaviour surprises most people: When the
// first salary is changed, the entry no longer fullfills the query, so it is dropped from the
// view implicitly. view[0] is removed, view[1] moves to view[0] and so forth. But the next
// loop iteration has i=1 and refers to view[1], thus skipping view[0]. The end result is that
// every other employee get a raise, while the others don't.
//
// 4. Iterating intermixed with implicit updates
// This leads us to use case 4, which is similar to use case 3, but uses promote_to_write()
// intermixed with iterating a view. This is actually quite important to some, who do not want
// to end up with a large write transaction.
//
// view = table.where().less_than(salary_column,limit).find_all();
// for (size_t i = 0; i < view.size(); ++i) {
// promote_to_write();
// view[i].set(salary_column, limit);
// commit_and_continue_as_write();
// }
//
// Anything can happen at the call to promote_to_write(). The key question then becomes: how
// do we support a safe way of realising the original goal (raising salaries) ?
//
// using the imperative operating mode:
//
// view = table.where().less_than(salary_column,limit).find_all();
// for (size_t i = 0; i < view.size(); ++i) {
// promote_to_write();
// // add r.sync_if_needed(); to get reflective mode
// if (r.is_obj_valid(i)) {
// auto r = view[i];
// view[i].set(salary_column, limit);
// }
// commit_and_continue_as_write();
// }
//
// This is safe, and we just aim for providing low level safety: is_obj_valid() can tell
// if the reference is valid, and the references in the view continue to point to the
// same object at all times, also following implicit updates. The rest is up to the
// application logic.
//
// It is important to see, that there is no guarantee that all relevant employees get
// their raise in cases whith concurrent updates. At every call to promote_to_write() new
// employees may be added to the underlying table, but as the view is in imperative mode,
// these new employees are not added to the view. Also at promote_to_write() an existing
// employee could recieve a (different, larger) raise which would then be overwritten and lost.
// However, these are problems that you should expect, since the activity is spread over multiple
// transactions.
/// A ConstTableView gives read access to the parent table, but no
/// write access. The view itself, though, can be changed, for
/// example, it can be sorted.
///
/// Note that methods are declared 'const' if, and only if they leave
/// the view unmodified, and this is irrespective of whether they
/// modify the parent table.
///
/// A ConstTableView has both copy and move semantics. See TableView
/// for more on this.
class ConstTableView : public ObjList {
public:
/// Construct null view (no memory allocated).
ConstTableView()
{
}
/// Construct empty view, ready for addition of row indices.
ConstTableView(ConstTableRef parent);
ConstTableView(ConstTableRef parent, Query& query, size_t start, size_t end, size_t limit);
ConstTableView(ConstTableRef parent, ColKey column, const Obj& obj);
ConstTableView(ConstTableRef parent, LnkLstPtr link_list);
ConstTableView(ConstTableRef parent, LnkSetPtr link_list);
/// Copy constructor.
ConstTableView(const ConstTableView&);
/// Move constructor.
ConstTableView(ConstTableView&&) noexcept;
ConstTableView& operator=(const ConstTableView&);
ConstTableView& operator=(ConstTableView&&) noexcept;
ConstTableView(ConstTableView& source, Transaction* tr, PayloadPolicy mode);
~ConstTableView()
{
}
TableRef get_target_table() const override
{
return m_table.cast_away_const();
}
size_t size() const override
{
return m_key_values.size();
}
bool is_empty() const noexcept
{
return m_key_values.size() == 0;
}
// Tells if the table that this TableView points at still exists or has been deleted.
bool is_attached() const noexcept
{
return bool(m_table);
}
ObjKey get_key(size_t ndx) const override
{
return m_key_values.get(ndx);
}
bool is_obj_valid(size_t ndx) const noexcept override
{
return m_table->is_valid(get_key(ndx));
}
Obj get_object(size_t ndx) const override
{
return m_table.cast_away_const()->get_object(get_key(ndx));
}
// 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
{
return m_query;
}
// Change the TableView to be backed by another query
// only works if the TableView is already backed by a query, and both
// queries points to the same Table
void update_query(const Query& q);
std::unique_ptr<ConstTableView> clone() const
{
return std::unique_ptr<ConstTableView>(new ConstTableView(*this));
}
LinkCollectionPtr clone_obj_list() const final
{
return std::unique_ptr<ConstTableView>(new ConstTableView(*this));
}
// import_copy_of() machinery entry points based on dynamic type. These methods:
// a) forward their calls to the static type entry points.
// b) new/delete patch data structures.
std::unique_ptr<ConstTableView> clone_for_handover(Transaction* tr, PayloadPolicy mode)
{
std::unique_ptr<ConstTableView> retval(new ConstTableView(*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 <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;
/// 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
{
return m_key_values.find_first(key);
}
// Conversion
void to_json(std::ostream&, size_t link_depth = 0) const;
// Determine if the view is 'in sync' with the underlying table
// as well as other views used to generate the view. Note that updates
// through views maintains synchronization between view and table.
// It doesnt by itself maintain other views as well. So if a view
// is generated from another view (not a table), updates may cause
// that view to be outdated, AND as the generated view depends upon
// it, it too will become outdated.
bool is_in_sync() const override;
// A TableView is frozen if it is a) obtained from a query against a frozen table
// and b) is synchronized (is_in_sync())
bool is_frozen()
{
return m_table->is_frozen() && is_in_sync();
}
// Tells if this TableView depends on a LinkList or row that has been deleted.
bool depends_on_deleted_object() const;
// Synchronize a view to match a table or tableview from which it
// has been derived. Synchronization is achieved by rerunning the
// query used to generate the view. If derived from another view, that
// view will be synchronized as well.
//
// "live" or "reactive" views are implemented by calling sync_if_needed()
// before any of the other access-methods whenever the view may have become
// outdated.
void sync_if_needed() const override;
// Return the version of the source it was created from.
TableVersions get_dependency_versions() const
{
TableVersions ret;
get_dependencies(ret);
return ret;
}
// Sort m_key_values according to one column
void sort(ColKey column, bool ascending = true);
// Sort m_key_values according to multiple columns
void sort(SortDescriptor order);
// Get the number of total results which have been filtered out because a number of "LIMIT" operations have
// been applied. This number only applies to the last sync.
size_t get_num_results_excluded_by_limit() const noexcept
{
return m_limit_count;
}
// Remove rows that are duplicated with respect to the column set passed as argument.
// distinct() will preserve the original order of the row pointers, also if the order is a result of sort()
// If two rows are indentical (for the given set of distinct-columns), then the last row is removed.
// You can call sync_if_needed() to update the distinct view, just like you can for a sorted view.
// Each time you call distinct() it will compound on the previous calls
void distinct(ColKey column);
void distinct(DistinctDescriptor columns);
void limit(LimitDescriptor limit);
// Replace the order of sort and distinct operations, bypassing manually
// calling sort and distinct. This is a convenience method for bindings.
void apply_descriptor_ordering(const DescriptorOrdering& new_ordering);
// Gets a readable and parsable string which completely describes the sort and
// distinct operations applied to this view.
std::string get_descriptor_ordering_description() const;
// Returns whether the rows are guaranteed to be in table order.
// This is true only of unsorted TableViews created from either:
// - Table::find_all()
// - Query::find_all() when the query is not restricted to a view.
bool is_in_table_order() const;
bool is_backlink_view() const
{
return m_source_column_key != ColKey();
}
protected:
// This TableView can be "born" from 4 different sources:
// - LinkView
// - Query::find_all()
// - Table::get_distinct_view()
// - Table::get_backlink_view()
void get_dependencies(TableVersions&) const override;
void do_sync();
void do_sort(const DescriptorOrdering&);
mutable ConstTableRef m_table;
// The source column index that this view contain backlinks for.
ColKey m_source_column_key;
// The target object that rows in this view link to.
ObjKey m_linked_obj_key;
ConstTableRef m_linked_table;
// If this TableView was created from a LnkLst, then this reference points to it. Otherwise it's 0
mutable LnkLstPtr m_linklist_source;
// If this TableView was created from a LnkSet, then this reference points to it. Otherwise it's 0
mutable LnkSetPtr m_linkset_source;
// Stores the ordering criteria of applied sort and distinct operations.
DescriptorOrdering m_descriptor_ordering;
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;
// parameters for findall, needed to rerun the query
size_t m_start = 0;
size_t m_end = size_t(-1);
size_t m_limit = size_t(-1);
// FIXME: This class should eventually be replaced by std::vector<ObjKey>
// It implements a vector of ObjKey, where the elements are held in the
// heap (default allocator is the only option)
class KeyValues : public KeyColumn {
public:
KeyValues()
: KeyColumn(Allocator::get_default())
{
}
KeyValues(const KeyValues&) = delete;
~KeyValues()
{
destroy();
}
void move_from(KeyValues&);
void copy_from(const KeyValues&);
};
mutable TableVersions m_last_seen_versions;
KeyValues m_key_values;
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;
util::RaceDetector m_race_detector;
friend class Table;
friend class Obj;
friend class Query;
friend class DB;
friend class ObjList;
};
enum class RemoveMode { ordered, unordered };
/// A TableView gives read and write access to the parent table.
///
/// A 'const TableView' cannot be changed (e.g. sorted), nor can the
/// parent table be modified through it.
///
/// A TableView is both copyable and movable.
class TableView : public ConstTableView {
public:
using ConstTableView::ConstTableView;
TableView() = default;
TableRef get_parent() noexcept
{
return m_table.cast_away_const();
}
// Rows
Obj get(size_t row_ndx);
Obj front();
Obj back();
Obj operator[](size_t row_ndx);
/// \defgroup table_view_removes
//@{
/// \brief Remove the specified row (or rows) from the underlying table.
///
/// remove() removes the specified row from the underlying table,
/// remove_last() removes the last row in the table view from the underlying
/// table, and clear removes all the rows in the table view from the
/// underlying table.
///
/// When rows are removed from the underlying table, they will by necessity
/// also be removed from the table view. The order of the remaining rows in
/// the the table view will be maintained.
///
/// \param row_ndx The index within this table view of the row to be removed.
void remove(size_t row_ndx);
void remove_last();
void clear();
//@}
std::unique_ptr<TableView> clone() const
{
return std::unique_ptr<TableView>(new TableView(*this));
}
std::unique_ptr<TableView> clone_for_handover(Transaction* tr, PayloadPolicy policy)
{
std::unique_ptr<TableView> retval(new TableView(*this, tr, policy));
return retval;
}
private:
TableView(TableRef parent);
TableView(TableRef parent, Query& query, size_t start, size_t end, size_t limit);
TableView(TableRef parent, LnkLstPtr);
friend class ConstTableView;
friend class Table;
friend class Query;
friend class LnkLst;
};
// ================================================================================================
// ConstTableView Implementation:
inline ConstTableView::ConstTableView(ConstTableRef parent)
: m_table(parent) // Throws
{
m_key_values.create();
if (m_table) {
m_last_seen_versions.emplace_back(m_table->get_key(), m_table->get_content_version());
}
}
inline ConstTableView::ConstTableView(ConstTableRef parent, Query& query, size_t start, size_t end, size_t lim)
: m_table(parent)
, m_query(query)
, m_start(start)
, m_end(end)
, m_limit(lim)
{
m_key_values.create();
}
inline ConstTableView::ConstTableView(ConstTableRef src_table, ColKey src_column_key, const Obj& obj)
: m_table(src_table) // Throws
, m_source_column_key(src_column_key)
, m_linked_obj_key(obj.get_key())
, m_linked_table(obj.get_table())
{
m_key_values.create();
if (m_table) {
m_last_seen_versions.emplace_back(m_table->get_key(), m_table->get_content_version());
m_last_seen_versions.emplace_back(obj.get_table()->get_key(), obj.get_table()->get_content_version());
}
}
inline ConstTableView::ConstTableView(ConstTableRef parent, LnkLstPtr link_list)
: m_table(parent) // Throws
, m_linklist_source(std::move(link_list))
{
REALM_ASSERT(m_linklist_source);
m_key_values.create();
if (m_table) {
m_last_seen_versions.emplace_back(m_table->get_key(), m_table->get_content_version());
}
}
inline ConstTableView::ConstTableView(ConstTableRef parent, LnkSetPtr link_set)
: m_table(parent) // Throws
, m_linkset_source(std::move(link_set))
{
REALM_ASSERT(m_linkset_source);
m_key_values.create();
if (m_table) {
m_last_seen_versions.emplace_back(m_table->get_key(), m_table->get_content_version());
}
}
inline ConstTableView::ConstTableView(const ConstTableView& tv)
: m_table(tv.m_table)
, m_source_column_key(tv.m_source_column_key)
, m_linked_obj_key(tv.m_linked_obj_key)
, m_linked_table(tv.m_linked_table)
, m_linklist_source(tv.m_linklist_source ? tv.m_linklist_source->clone_linklist() : LnkLstPtr{})
, m_linkset_source(tv.m_linkset_source ? tv.m_linkset_source->clone_linkset() : LnkSetPtr{})
, m_descriptor_ordering(tv.m_descriptor_ordering)
, m_query(tv.m_query)
, m_start(tv.m_start)
, m_end(tv.m_end)
, m_limit(tv.m_limit)
, m_last_seen_versions(tv.m_last_seen_versions)
{
m_key_values.copy_from(tv.m_key_values);
m_limit_count = tv.m_limit_count;
}
inline ConstTableView::ConstTableView(ConstTableView&& tv) noexcept
: m_table(tv.m_table)
, m_source_column_key(tv.m_source_column_key)
, m_linked_obj_key(tv.m_linked_obj_key)
, m_linked_table(tv.m_linked_table)
, m_linklist_source(std::move(tv.m_linklist_source))
, m_linkset_source(std::move(tv.m_linkset_source))
, m_descriptor_ordering(std::move(tv.m_descriptor_ordering))
, m_query(std::move(tv.m_query))
, m_start(tv.m_start)
, m_end(tv.m_end)
, m_limit(tv.m_limit)
// if we are created from a table view which is outdated, take care to use the outdated
// version number so that we can later trigger a sync if needed.
, m_last_seen_versions(std::move(tv.m_last_seen_versions))
{
m_key_values.move_from(tv.m_key_values);
m_limit_count = tv.m_limit_count;
}
inline ConstTableView& ConstTableView::operator=(ConstTableView&& tv) noexcept
{
m_table = std::move(tv.m_table);
m_key_values.move_from(tv.m_key_values);
m_query = std::move(tv.m_query);
m_last_seen_versions = tv.m_last_seen_versions;
m_start = tv.m_start;
m_end = tv.m_end;
m_limit = tv.m_limit;
m_limit_count = tv.m_limit_count;
m_source_column_key = tv.m_source_column_key;
m_linked_obj_key = tv.m_linked_obj_key;
m_linked_table = tv.m_linked_table;
m_linklist_source = std::move(tv.m_linklist_source);
m_linkset_source = std::move(tv.m_linkset_source);
m_descriptor_ordering = std::move(tv.m_descriptor_ordering);
return *this;
}
inline ConstTableView& ConstTableView::operator=(const ConstTableView& tv)
{
if (this == &tv)
return *this;
m_key_values.copy_from(tv.m_key_values);
m_query = tv.m_query;
m_last_seen_versions = tv.m_last_seen_versions;
m_start = tv.m_start;
m_end = tv.m_end;
m_limit = tv.m_limit;
m_limit_count = tv.m_limit_count;
m_source_column_key = tv.m_source_column_key;
m_linked_obj_key = tv.m_linked_obj_key;
m_linked_table = tv.m_linked_table;
m_linklist_source = tv.m_linklist_source ? tv.m_linklist_source->clone_linklist() : LnkLstPtr{};
m_linkset_source = tv.m_linkset_source ? tv.m_linkset_source->clone_linkset() : LnkSetPtr{};
m_descriptor_ordering = tv.m_descriptor_ordering;
return *this;
}
#define REALM_ASSERT_COLUMN(column_key) \
m_table.check(); \
REALM_ASSERT(m_table->colkey2ndx(column_key))
#define REALM_ASSERT_ROW(row_ndx) \
m_table.check(); \
REALM_ASSERT(row_ndx < m_key_values.size())
#define REALM_ASSERT_COLUMN_AND_TYPE(column_key, column_type) \
REALM_ASSERT_COLUMN(column_key); \
REALM_DIAG_PUSH(); \
REALM_DIAG_IGNORE_TAUTOLOGICAL_COMPARE(); \
REALM_ASSERT(m_table->get_column_type(column_key) == column_type); \
REALM_DIAG_POP()
#define REALM_ASSERT_INDEX(column_key, row_ndx) \
REALM_ASSERT_COLUMN(column_key); \
REALM_ASSERT(row_ndx < m_key_values.size())
#define REALM_ASSERT_INDEX_AND_TYPE(column_key, row_ndx, column_type) \
REALM_ASSERT_COLUMN_AND_TYPE(column_key, column_type); \
REALM_ASSERT(row_ndx < m_key_values.size())
#define REALM_ASSERT_INDEX_AND_TYPE_TABLE_OR_MIXED(column_key, row_ndx) \
REALM_ASSERT_COLUMN(column_key); \
REALM_DIAG_PUSH(); \
REALM_DIAG_IGNORE_TAUTOLOGICAL_COMPARE(); \
REALM_ASSERT(m_table->get_column_type(column_key) == type_Table || \
(m_table->get_column_type(column_key) == type_Mixed)); \
REALM_DIAG_POP(); \
REALM_ASSERT(row_ndx < m_key_values.size())
//-------------------------- TableView, ConstTableView implementation:
template <class T>
ConstTableView ObjList::find_all(ColKey column_key, T value) const
{
ConstTableView tv(get_target_table());
auto& keys = tv.m_key_values;
for_each([column_key, value, &keys](const Obj& o) {
if (o.get<T>(column_key) == value) {
keys.add(o.get_key());
}
return false;
});
return tv;
}
inline void TableView::remove_last()
{
if (!is_empty())
remove(size() - 1);
}
inline TableView::TableView(TableRef parent)
: ConstTableView(parent)
{
}
inline TableView::TableView(TableRef parent, Query& query, size_t start, size_t end, size_t lim)
: ConstTableView(parent, query, start, end, lim)
{
}
inline TableView::TableView(TableRef parent, LnkLstPtr link_list)
: ConstTableView(parent, std::move(link_list))
{
}
// Rows
inline Obj TableView::get(size_t row_ndx)
{
REALM_ASSERT_ROW(row_ndx);
ObjKey key(m_key_values.get(row_ndx));
REALM_ASSERT(key != realm::null_key);
return get_parent()->get_object(key);
}
inline Obj TableView::front()
{
return get(0);
}
inline Obj TableView::back()
{
size_t last_row_ndx = size() - 1;
return get(last_row_ndx);
}
inline Obj TableView::operator[](size_t row_ndx)
{
return get(row_ndx);
}
} // namespace realm
#endif // REALM_TABLE_VIEW_HPP