From ac807d2d71c4bca73328c65b0f386849b032f1a5 Mon Sep 17 00:00:00 2001 From: cbullinger Date: Thu, 4 Sep 2025 14:47:11 -0400 Subject: [PATCH 1/3] Add markdown docs to new docs-sdk/ dir for community access (cherry picked from commit d62fca6d283e6bf4f3b969bf9329719d649514c4) --- docs-sdk/cpp.md | 41 ++ docs-sdk/crud.md | 9 + docs-sdk/crud/create.md | 462 +++++++++++++++++ docs-sdk/crud/delete.md | 98 ++++ docs-sdk/crud/filter-data.md | 155 ++++++ docs-sdk/crud/read.md | 204 ++++++++ docs-sdk/crud/threading.md | 480 ++++++++++++++++++ docs-sdk/crud/update.md | 261 ++++++++++ docs-sdk/images/geoboxes-query.png | Bin 0 -> 17903 bytes docs-sdk/images/geoboxes.png | Bin 0 -> 10430 bytes docs-sdk/images/geocircles-query.png | Bin 0 -> 29675 bytes docs-sdk/images/geocircles.png | Bin 0 -> 22501 bytes docs-sdk/images/geopoints.png | Bin 0 -> 10572 bytes docs-sdk/images/geopolygons-query.png | Bin 0 -> 50094 bytes docs-sdk/images/geopolygons.png | Bin 0 -> 56163 bytes docs-sdk/images/mvcc-diagram.png | Bin 0 -> 46622 bytes docs-sdk/install.md | 144 ++++++ docs-sdk/logging.md | 42 ++ docs-sdk/model-data.md | 6 + docs-sdk/model-data/object-models.md | 198 ++++++++ docs-sdk/model-data/relationships.md | 124 +++++ docs-sdk/model-data/supported-types.md | 160 ++++++ docs-sdk/quick-start.md | 117 +++++ docs-sdk/react-to-changes.md | 262 ++++++++++ docs-sdk/realm-files.md | 6 + docs-sdk/realm-files/compact-realm.md | 82 +++ .../realm-files/configure-and-open-a-realm.md | 129 +++++ docs-sdk/realm-files/encrypt-a-realm.md | 60 +++ 28 files changed, 3040 insertions(+) create mode 100644 docs-sdk/cpp.md create mode 100644 docs-sdk/crud.md create mode 100644 docs-sdk/crud/create.md create mode 100644 docs-sdk/crud/delete.md create mode 100644 docs-sdk/crud/filter-data.md create mode 100644 docs-sdk/crud/read.md create mode 100644 docs-sdk/crud/threading.md create mode 100644 docs-sdk/crud/update.md create mode 100644 docs-sdk/images/geoboxes-query.png create mode 100644 docs-sdk/images/geoboxes.png create mode 100644 docs-sdk/images/geocircles-query.png create mode 100644 docs-sdk/images/geocircles.png create mode 100644 docs-sdk/images/geopoints.png create mode 100644 docs-sdk/images/geopolygons-query.png create mode 100644 docs-sdk/images/geopolygons.png create mode 100644 docs-sdk/images/mvcc-diagram.png create mode 100644 docs-sdk/install.md create mode 100644 docs-sdk/logging.md create mode 100644 docs-sdk/model-data.md create mode 100644 docs-sdk/model-data/object-models.md create mode 100644 docs-sdk/model-data/relationships.md create mode 100644 docs-sdk/model-data/supported-types.md create mode 100644 docs-sdk/quick-start.md create mode 100644 docs-sdk/react-to-changes.md create mode 100644 docs-sdk/realm-files.md create mode 100644 docs-sdk/realm-files/compact-realm.md create mode 100644 docs-sdk/realm-files/configure-and-open-a-realm.md create mode 100644 docs-sdk/realm-files/encrypt-a-realm.md diff --git a/docs-sdk/cpp.md b/docs-sdk/cpp.md new file mode 100644 index 00000000..1cd34eac --- /dev/null +++ b/docs-sdk/cpp.md @@ -0,0 +1,41 @@ +# Realm SDK for C++ +Use Realm SDK for C++ to write applications that access data +stored locally on devices. + +## Get Started with the C++ SDK +These docs provide minimal-explanation code examples of how to work with the C++ SDK. +Use the SDK's open-source database - Realm - as an object store on the +device. + +> **TIP:** See the [Quick Start](/docs/quick-start.md) to integrate +> Realm into your project and get started. +> + +### Install the C++ SDK +To get started, Swift Package Manager or Cmake to install the C++ SDK +in your project. + +Include the header in the translation unit where you want to +use it to get started. + +### Define an Object Schema +Use C++ to idiomatically define an object type. + +### Open a Database +The SDK's database - Realm - stores objects in files on your device. +Configure and open a database +to get started reading and writing data. + +### Read and Write Data +- Create, read, update, and delete objects from the database. +- Filter data using the SDK's query engine. + +### React to Changes +Live objects mean that your data is always up-to-date. +You can register a notification handler +to watch for changes and perform some logic, such as updating +your UI. + +## Recommended Reading +### C++ API Reference +Explore generated Doxygen reference docs for the C++ APIs. diff --git a/docs-sdk/crud.md b/docs-sdk/crud.md new file mode 100644 index 00000000..ce70d11d --- /dev/null +++ b/docs-sdk/crud.md @@ -0,0 +1,9 @@ +# CRUD - C++ SDK +Use the following pages to learn and reference CRUD operations: + +- [Create](crud/create.md) +- [Read](crud/read.md) +- [Update](crud/update.md) +- [Delete](crud/delete.md) +- [Filter Data](crud/filter-data.md) +- [Threading](crud/threading.md) diff --git a/docs-sdk/crud/create.md b/docs-sdk/crud/create.md new file mode 100644 index 00000000..f24af1cb --- /dev/null +++ b/docs-sdk/crud/create.md @@ -0,0 +1,462 @@ +# CRUD - Create - C++ SDK +## Write Transactions +Realm uses a highly efficient storage engine +to persist objects. You can **create** objects in a realm, +**update** objects in a realm, and eventually **delete** +objects from a realm. Because these operations modify the +state of the realm, we call them writes. + +Realm handles writes in terms of **transactions**. A +transaction is a list of read and write operations that +Realm treats as a single indivisible operation. In other +words, a transaction is *all or nothing*: either all of the +operations in the transaction succeed or none of the +operations in the transaction take effect. + +All writes must happen in a transaction. + +A realm allows only one open transaction at a time. Realm +blocks other writes on other threads until the open +transaction is complete. Consequently, there is no race +condition when reading values from the realm within a +transaction. + +When you are done with your transaction, Realm either +**commits** it or **cancels** it: + +- When Realm **commits** a transaction, Realm writes +all changes to disk. +- When Realm **cancels** a write transaction or an operation in +the transaction causes an error, all changes are discarded +(or "rolled back"). + +## Create a New Object +### Create an Object +To create an object, you must instantiate it using the `realm` namespace. +Move the object into the realm using the +Realm.add() function +inside of a write transaction. + +When you move an object into a realm, this consumes the object as an +rvalue. You must use the managed object for any data access or observation. +In this example, copying the `dog` object into the realm consumes +it as an rvalue. You can return the managed object to continue to work +with it. + +```cpp +// Create an object using the `realm` namespace. +auto dog = realm::Dog{.name = "Rex", .age = 1}; + +std::cout << "dog: " << dog.name << "\n"; + +// Open the database with compile-time schema checking. +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +// Persist your data in a write transaction +// Optionally return the managed object to work with it immediately +auto managedDog = realm.write([&] { return realm.add(std::move(dog)); }); + +``` + +#### Model +For more information about modeling an object, refer to: +Define a New Object Type. + +```cpp +namespace realm { +struct Dog { + std::string name; + int64_t age; +}; +REALM_SCHEMA(Dog, name, age) +} // namespace realm + +``` + +### Create an Embedded Object +To create an embedded object, assign the raw pointer of the embedded +object to a parent object's property. Move the parent object into +the realm using the Realm.add() function +inside of a write transaction. + +In this example, we assign the raw pointer of the embedded object - +`ContactDetails *` - to the embedded object property of the parent +object - `Business.contactDetails`. + +Then, we add the `business` object to the realm. This copies the +`business` and `contactDetails` objects to the realm. + +Because `ContactDetails` is an embedded object, it does not have +its own lifecycle independent of the main `Business` object. +If you delete the `Business` object, this also deletes the +`ContactDetails` object. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto contactDetails = realm::ContactDetails{ + .emailAddress = "email@example.com", .phoneNumber = "123-456-7890"}; +auto business = realm::Business(); +business._id = realm::object_id::generate(); +business.name = "my business"; +business.contactDetails = &contactDetails; + +realm.write([&] { realm.add(std::move(business)); }); + +``` + +#### Model +For more information about modeling an embedded object, refer to: +Define an Embedded Object. + +```cpp +namespace realm { +struct ContactDetails { + // Because ContactDetails is an embedded object, it cannot have its own _id + // It does not have a lifecycle outside of the top-level object + std::string emailAddress; + std::string phoneNumber; +}; +REALM_EMBEDDED_SCHEMA(ContactDetails, emailAddress, phoneNumber) + +struct Business { + realm::object_id _id; + std::string name; + ContactDetails *contactDetails; +}; +REALM_SCHEMA(Business, _id, name, contactDetails) +} // namespace realm + +``` + +### Create an Object with a To-One Relationship +To create an object with a to-one relationship to another object, +assign the raw pointer of the related object to the relationship +property of the main object. Move the object into the realm using +the Realm.add() function +inside of a write transaction. + +In this example, we assign the raw pointer of the related object - +`FavoriteToy *` - to the relationship property of the main object +- `Dog.favoriteToy`. Then, when we add the `dog` object to the +realm, this copies both the `dog` and `favoriteToy` to the realm. + +The related `favoriteToy` object has its own lifecycle independent +of the main `dog` object. If you delete the main object, the related +object remains. + +```cpp +auto config = realm::db_config(); +auto realmInstance = realm::db(std::move(config)); + +auto favoriteToy = realm::FavoriteToy{ + ._id = realm::uuid("68b696c9-320b-4402-a412-d9cee10fc6a5"), + .name = "Wubba"}; + +auto dog = realm::Dog{ + ._id = realm::uuid("68b696d7-320b-4402-a412-d9cee10fc6a3"), + .name = "Lita", + .age = 10, + .favoriteToy = &favoriteToy}; + +realmInstance.write([&] { realmInstance.add(std::move(dog)); }); + +``` + +You can optionally create an inverse relationship to refer to the main object +from the related object. For more information, refer to: +Create an Object with an Inverse Relationship. + +#### Model +For more information about modeling a to-one relationship, refer to: +Define a To-One Relationship. + +```cpp +struct FavoriteToy { + realm::primary_key _id; + std::string name; +}; +REALM_SCHEMA(FavoriteToy, _id, name) + +struct Dog { + realm::primary_key _id; + std::string name; + int64_t age; + + // Define a relationship as a link to another SDK object + FavoriteToy* favoriteToy; +}; +REALM_SCHEMA(Dog, _id, name, age, favoriteToy) + +``` + +### Create an Object with a To-Many Relationship +To create an object with a to-many relationship to one or more objects: + +- Initialize the main object and the related objects +- Use the push_back +member function available to the Realm object lists +to append the raw pointers of the related objects to the main object's +list property +- Move the object into the realm using the +Realm.add() function +inside of a write transaction. + +In this example, we append the raw pointers of the related objects - +`Employee *` - to the relationship property of the main object +- `Company.employees`. This creates a one-way connection from the +`Company` object to the `Employee` objects. + +Then, we add the `Company` to the realm. This copies the +`Company` and `Employee` objects to the realm. + +The related `Employee` objects have their own lifecycle independent +of the main `Company` object. If you delete the main object, the +related objects remain. + +```cpp +auto config = realm::db_config(); +auto realmInstance = realm::db(std::move(config)); + +auto employee1 = realm::Employee{ + ._id = 23456, .firstName = "Pam", .lastName = "Beesly"}; + +auto employee2 = realm::Employee{ + ._id = 34567, .firstName = "Jim", .lastName = "Halpert"}; + +auto company = + realm::Company{._id = 45678, .name = "Dunder Mifflin"}; + +// Use the `push_back` member function available to the +// `ListObjectPersistable` template to append `Employee` objects to +// the `Company` `employees` list property. +company.employees.push_back(&employee1); +company.employees.push_back(&employee2); + +realmInstance.write([&] { realmInstance.add(std::move(company)); }); + +``` + +You can optionally create an inverse relationship to refer to the main object +from the related object. For more information, refer to: +Create an Object with an Inverse Relationship. + +#### Model +For more information about modeling a to-many relationship, refer to: +Define a To-Many Relationship. + +```cpp +namespace realm { +struct Employee { + realm::primary_key _id; + std::string firstName; + std::string lastName; + + // You can use this property as you would any other member + // Omitting it from the schema means the SDK ignores it + std::string jobTitle_notPersisted; +}; +// The REALM_SCHEMA omits the `jobTitle_notPersisted` property +// The SDK does not store and cannot retrieve a value for this property +REALM_SCHEMA(Employee, _id, firstName, lastName) +} // namespace realm + +``` + +```cpp +struct Company { + int64_t _id; + std::string name; + // To-many relationships are a list, represented here as a + // vector container whose value type is the SDK object + // type that the list field links to. + std::vector employees; +}; +REALM_SCHEMA(Company, _id, name, employees) + +``` + +### Create an Object with an Inverse Relationship +To create an object with a inverse relationship to another object, +assign the raw pointer of the related object to the relationship +property of the main object. Move the object into the realm using the +Realm.add() function +inside of a write transaction. + +In this example, we create two `Person` objects that each have a to-one +relationship to the same `Dog` object. The `Dog` has an inverse +relationship to each `Person` object. The inverse relationship backlink +is automatically updated when a linked `Person` object updates its +`Dog` relationship. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto dog = realm::Dog{.name = "Bowser"}; + +auto [jack, jill] = realm.write([&realm]() { + auto person = + realm::Person{.name = "Jack", .age = 27, .dog = nullptr}; + + realm::Person person2; + person2.name = "Jill"; + person2.age = 28; + person2.dog = nullptr; + + return realm.insert(std::move(person), std::move(person2)); +}); + +realm.write([&dog, jack = &jack]() { jack->dog = &dog; }); + +// After assigning `&dog` to jack's `dog` property, +// the backlink automatically updates to reflect +// the inverse relationship through the dog's `owners` +// property +CHECK(jack.dog->owners.size() == 1); + +realm.write([&dog, jill = &jill]() { jill->dog = &dog; }); + +// After assigning the same `&dog` to jill's `dog` +// property, the backlink automatically updates +CHECK(jill.dog->owners.size() == 2); +CHECK(jack.dog->owners.size() == 2); + +// Removing the relationship from the parent object +// automatically updates the inverse relationship +realm.write([jack = &jack]() { jack->dog = nullptr; }); +CHECK(jack.dog == nullptr); +CHECK(jill.dog->owners.size() == 1); + +``` + +#### Model +For more information about modeling an inverse relationship, refer to: +Define an Inverse Relationship. + +```cpp +struct Dog; +struct Person { + realm::primary_key _id; + std::string name; + int64_t age = 0; + Dog* dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) +struct Dog { + realm::primary_key _id; + std::string name; + int64_t age = 0; + linking_objects<&Person::dog> owners; +}; +REALM_SCHEMA(Dog, _id, name, age, owners) + +``` + +### Create an Object with a Map Property +When you create an object that has a +map property, +you can set the values for keys in a few ways: + +- Set keys and values on the object and then add the object to the realm +- Set the object's keys and values directly inside a write transaction + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto employee = realm::Employee{ + ._id = 8675309, .firstName = "Tommy", .lastName = "Tutone"}; + +employee.locationByDay = { + {"Monday", realm::Employee::WorkLocation::HOME}, + {"Tuesday", realm::Employee::WorkLocation::OFFICE}, + {"Wednesday", realm::Employee::WorkLocation::HOME}, + {"Thursday", realm::Employee::WorkLocation::OFFICE}}; + +realm.write([&] { + realm.add(std::move(employee)); + employee.locationByDay["Friday"] = realm::Employee::WorkLocation::HOME; +}); + +``` + +Realm disallows the use of `.` or `$` characters in map keys. +You can use percent encoding and decoding to store a map key that contains +one of these disallowed characters. + +```cpp +// Percent encode . or $ characters to use them in map keys +auto mapKey = "Monday.Morning"; +auto encodedMapKey = "Monday%2EMorning"; + +``` + +#### Model +For more information about supported map data types, refer to: +Map/Dictionary. + +```cpp +namespace realm { +struct Employee { + enum class WorkLocation { HOME, OFFICE }; + + int64_t _id; + std::string firstName; + std::string lastName; + std::map locationByDay; +}; +REALM_SCHEMA(Employee, _id, firstName, lastName, locationByDay) +} // namespace realm + +``` + +### Create an Object with a Set Property +You can create objects that contain +set +properties as you would any Realm object, but you can only mutate a set +property within a write transaction. This means you can only set the value(s) +of a set property within a write transaction. + +```cpp +auto realm = realm::db(std::move(config)); + +// Create an object that has a set property +auto docsRealmRepo = + realm::Repository{.ownerAndName = "mongodb/docs-realm"}; + +// Add the object to the database and get the managed object +auto managedDocsRealm = + realm.write([&]() { return realm.add(std::move(docsRealmRepo)); }); + +// Insert items into the set +auto openPullRequestNumbers = {3059, 3062, 3064}; + +realm.write([&] { + for (auto number : openPullRequestNumbers) { + // You can only mutate the set in a write transaction. + // This means you can't set values at initialization, + // but must do it during a write. + managedDocsRealm.openPullRequestNumbers.insert(number); + } +}); + +``` + +#### Model +For more information about supported set data types, refer to: +Set. + +```cpp +namespace realm { +struct Repository { + std::string ownerAndName; + std::set openPullRequestNumbers; +}; +REALM_SCHEMA(Repository, ownerAndName, openPullRequestNumbers) +} // namespace realm + +``` + diff --git a/docs-sdk/crud/delete.md b/docs-sdk/crud/delete.md new file mode 100644 index 00000000..c9bbc1b1 --- /dev/null +++ b/docs-sdk/crud/delete.md @@ -0,0 +1,98 @@ +# CRUD - Delete - C++ SDK +## Delete Realm Objects +Deleting Realm Objects must occur within write transactions. For +more information about write transactions, see: Write Transactions. + +### Delete an Object +To delete an object from a realm, pass the object to +Realm.remove() function +inside of a write transaction. + +```cpp +realm.write([&] { realm.remove(managedDog); }); + +``` + +### Delete an Inverse Relationship +You can't delete an inverse relationship directly. Instead, an +inverse relationship automatically updates by removing the relationship +through the related object. + +In this example, a `Person` has a to-one relationship to a `Dog`, +and the `Dog` has an inverse relationship to `Person`. +Setting the `Person.dog` relationship to `nullptr` removes the inverse +relationship from the `Dog` object. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto dog = realm::Dog{.name = "Wishbone"}; + +auto [joe] = realm.write([&realm]() { + auto person = + realm::Person{.name = "Joe", .age = 27, .dog = nullptr}; + return realm.insert(std::move(person)); +}); + +// Assign an object with an inverse relationship +// to automatically set the value of the inverse relationship +realm.write([&dog, joe = &joe]() { joe->dog = &dog; }); +CHECK(joe.dog->owners.size() == 1); + +// ... Later ... + +// Removing the relationship from the parent object +// automatically updates the inverse relationship +realm.write([joe = &joe]() { joe->dog = nullptr; }); +CHECK(realm.objects()[0].owners.size() == 0); + +``` + +#### Model +This example uses the following model: + +```cpp +struct Dog; +struct Person { + realm::primary_key _id; + std::string name; + int64_t age = 0; + Dog* dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) +struct Dog { + realm::primary_key _id; + std::string name; + int64_t age = 0; + linking_objects<&Person::dog> owners; +}; +REALM_SCHEMA(Dog, _id, name, age, owners) + +``` + +### Delete Map Keys/Values +To delete a map key, +pass the key name to `erase()`: + +```cpp +realm.write([&] { tommy.locationByDay.erase("Tuesday"); }); + +``` + +### Delete Set Values +You can delete a set element +with `erase()`, or remove all elements from a set with `clear()`. + +```cpp +// Remove an element from the set with erase() +auto it3064 = managedDocsRealm.openPullRequestNumbers.find(3064); +CHECK(it3064 != managedDocsRealm.openPullRequestNumbers.end()); +realm.write([&] { managedDocsRealm.openPullRequestNumbers.erase(it3065); }); +CHECK(managedDocsRealm.openPullRequestNumbers.size() == 4); + +// Clear the entire contents of the set +realm.write([&] { managedDocsRealm.openPullRequestNumbers.clear(); }); +CHECK(managedDocsRealm.openPullRequestNumbers.size() == 0); + +``` diff --git a/docs-sdk/crud/filter-data.md b/docs-sdk/crud/filter-data.md new file mode 100644 index 00000000..610c7c11 --- /dev/null +++ b/docs-sdk/crud/filter-data.md @@ -0,0 +1,155 @@ +# Filter Data - C++ SDK +To filter data in your realm, you can leverage +Realm's query engine. You can also sort filtered data. For an example of +how to sort query results, refer to Sort Lists and Query Results. + +> Note: +> The C++ SDK does not yet support the full range of query expressions +that the other SDKs provide. +> + +## About the Examples on This Page +The examples in this page use a simple data set for a +todo list app. The two Realm object types are `Project` +and `Item`. An `Item` has: + +- A name +- A completed flag +- An optional assignee's name +- A number representing priority, where higher is more important +- A count of minutes spent working on it + +A `Project` has a name and a to-many relationship to zero or more `Items`. + +The schemas for `Project` and `Item` are: + +```cpp +struct Item { + std::string name; + bool isComplete; + std::optional assignee; + int64_t priority; + int64_t progressMinutes; +}; +REALM_SCHEMA(Item, name, isComplete, assignee, priority, progressMinutes) + +struct Project { + std::string name; + std::vector items; +}; +REALM_SCHEMA(Project, name, items) + +``` + +You can set up the realm for these examples with the following code: + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto item1 = realm::Item{.name = "Save the cheerleader", + .assignee = std::string("Peter"), + .isComplete = false, + .priority = 6, + .progressMinutes = 30}; + +auto project = realm::Project{.name = "New project"}; + +project.items.push_back(&item1); + +realm.write([&] { realm.add(std::move(project)); }); + +auto items = realm.objects(); +auto projects = realm.objects(); + +``` + +## Filter Data +### Comparison Operators +Value comparisons + +|Operator|Description| +| --- | --- | +|==|Evaluates to `true` if the left-hand expression is equal to the right-hand expression.| +|>|Evaluates to `true` if the left-hand numerical or date expression is greater than the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is later than the right-hand date.| +|>=|Evaluates to `true` if the left-hand numerical or date expression is greater than or equal to the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is later than or the same as the right-hand date.| +|<|Evaluates to `true` if the left-hand numerical or date expression is less than the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is earlier than the right-hand date.| +|<=|Evaluates to `true` if the left-hand numeric expression is less than or equal to the right-hand numeric expression. For dates, this evaluates to `true` if the left-hand date is earlier than or the same as the right-hand date.| +|!=|Evaluates to `true` if the left-hand expression is not equal to the right-hand expression.| + +> Example: +> The following example uses the query engine's +comparison operators to: +> +> - Find high priority tasks by comparing the value of the `priority` property +value with a threshold number, above which priority can be considered high. +> - Find just-started or short-running tasks by seeing if the `progressMinutes` +property falls within a certain range. +> - Find unassigned tasks by finding tasks where the `assignee` property is +equal to `std::nullopt`. +> - Find tasks assigned to specific teammates Ali or Jamie by seeing if the +`assignee` property is in a list of names. +> +> ```cpp +> auto highPriorityItems = +> items.where([](auto const& item) { return item.priority > 5; }); +> +> auto quickItems = items.where([](auto const& item) { +> return item.progressMinutes > 1 && item.progressMinutes < 30; +> }); +> +> auto unassignedItems = items.where( +> [](auto const& item) { return item.assignee == std::nullopt; }); +> +> auto aliOrJamieItems = items.where([](auto const& item) { +> return item.assignee == std::string("Ali") || +> item.assignee == std::string("Jamie"); +> }); +> +> ``` +> + +### Logical Operators +You can use the logical operators listed in the following table to make compound +predicates: + +|Operator|Description| +| --- | --- | +|&&|Evaluates to `true` if both left-hand and right-hand expressions are `true`.| +|!|Negates the result of the given expression.| +|\\|\\||Evaluates to `true` if either expression returns `true`.| + +> Example: +> We can use the query language's logical operators to find +all of Ali's completed tasks. That is, we find all tasks +where the `assignee` property value is equal to 'Ali' AND +the `isComplete` property value is `true`: +> +> ```cpp +> auto completedItemsForAli = items.where([](auto const& item) { +> return item.assignee == std::string("Ali") && item.isComplete == true; +> }); +> +> ``` +> + +### String Operators +You can compare string values using these string operators. + +|Operator|Description| +| --- | --- | +|.contains(_ value: String)|Evaluates to `true` if the left-hand string expression is found anywhere in the right-hand string expression.| +|==|Evaluates to `true` if the left-hand string is lexicographically equal to the right-hand string.| +|!=|Evaluates to `true` if the left-hand string is not lexicographically equal to the right-hand string.| + +> Example: +> The following example uses the query engine's string operators to find: +> +> - Projects with names that contain 'ie' +> +> ```cpp +> auto containIe = +> items.where([](auto const& item) { return item.name.contains("ie"); }); +> +> ``` +> diff --git a/docs-sdk/crud/read.md b/docs-sdk/crud/read.md new file mode 100644 index 00000000..7fc38772 --- /dev/null +++ b/docs-sdk/crud/read.md @@ -0,0 +1,204 @@ +# CRUD - Read - C++ SDK +You can read back the data that you have stored in Realm by finding, +filtering, and sorting objects. + +A read from a realm generally consists of the following +steps: + +- Get all objects of a certain type from the realm. +- Optionally, filter the results. + +Query operations return a +results collection. These +collections are live, meaning they always contain the latest +results of the associated query. + +## Read Characteristics +Design your app's data access patterns around these three key +read characteristics to read data as efficiently as possible. + +### Results Are Not Copies +Results to a query are not copies of your data. Modifying +the results of a query modifies the data on disk +directly. This memory mapping also means that results are +**live**: that is, they always reflect the current state on +disk. + +### Results Are Lazy +Realm only runs a query when you actually request the +results of that query. This lazy evaluation enables you to write +highly performant code for handling large data sets and complex +queries. You can chain several filter operations without requiring +extra work to process the intermediate state. + +### References Are Retained +One benefit of Realm's object model is that +Realm automatically retains all of an object's +relationships as direct +references. This enables you to traverse your graph of relationships +directly through the results of a query. + +A **direct reference**, or pointer, allows you to access a +related object's properties directly through the reference. + +Other databases typically copy objects from database storage +into application memory when you need to work with them +directly. Because application objects contain direct +references, you are left with a choice: copy the object +referred to by each direct reference out of the database in +case it's needed, or just copy the foreign key for each +object and query for the object with that key if it's +accessed. If you choose to copy referenced objects into +application memory, you can use up a lot of resources for +objects that are never accessed, but if you choose to only +copy the foreign key, referenced object lookups can cause +your application to slow down. + +Realm bypasses all of this using zero-copy +live objects. Realm object accessors point +directly into database storage using memory mapping, so there is no +distinction between the objects in Realm and the results +of your query in application memory. Because of this, you can traverse +direct references across an entire realm from any query result. + +### Limiting Query Results +As a result of lazy evaluation, you do not need any special mechanism to +limit query results with Realm. For example, if your query +matches thousands of objects, but you only want to load the first ten, +simply access only the first ten elements of the results collection. + +### Pagination +Thanks to lazy evaluation, the common task of pagination becomes quite +simple. For example, suppose you have a results collection associated +with a query that matches thousands of objects in your realm. You +display one hundred objects per page. To advance to any page, simply +access the elements of the results collection starting at the index that +corresponds to the target page. + +## Read Realm Objects +### Query All Objects of a Given Type +To query for objects of a given type in a realm, pass the object type +`YourClassName` to the realm::query member function. + +This returns a Results object +representing all objects of the given type in the realm. + +```cpp +auto managedBusinesses = realm.objects(); + +``` + +### Filter Queries Based on Object Properties +A filter selects a subset of results based on the value(s) of one or +more object properties. Realm provides a full-featured +query engine that you can use to define filters. + +```cpp +auto businessesNamedMongoDB = managedBusinesses.where( + [](auto &business) { return business.name == "my business"; }); + +``` + +### Supported Query Operators +Currently, the Realm C++ SDK supports the following query operators: + +- Equality (`==`, `!=`) +- Greater than/less than (`>`, `>=`, `<`, `<=`) +- Compound queries (`||`, `&&`) + +### Check the Size of the Results Set and Access Results +Realm Results exposes member +functions to work with results. You may want to check the size of a results +set, or access the object at a specific index. + +```cpp +auto managedBusinesses = realm.objects(); +auto businessesNamedMongoDB = managedBusinesses.where( + [](auto &business) { return business.name == "my business"; }); +CHECK(businessesNamedMongoDB.size() >= 1); +auto mongoDB = businessesNamedMongoDB[0]; + +``` + +Additionally, you can iterate through the results, or observe a results +set for changes. + +### Read a Map Property +You can iterate and check the values of a realm map property +as you would a standard C++ [map](https://en.cppreference.com/w/cpp/container/map): + +```cpp +auto employees = realm.objects(); +auto employeesNamedTommy = employees.where( + [](auto &employee) { return employee.firstName == "Tommy"; }); +auto tommy = employeesNamedTommy[0]; +// You can get an iterator for an element matching a key using `find()` +auto tuesdayIterator = tommy.locationByDay.find("Tuesday"); + +// You can access values for keys like any other map type +auto mondayLocation = tommy.locationByDay["Monday"]; + +``` + +### Read a Set Property +You can iterate, check the size of a set, and find values in a set property: + +```cpp +auto repositories = realm.objects(); + +auto repositoriesNamedDocsRealm = repositories.where([](auto &repository) { + return repository.ownerAndName == "mongodb/docs-realm"; +}); + +auto docsRealm = repositoriesNamedDocsRealm[0]; + +// You can check the size of the set +auto numberOfPullRequests = docsRealm.openPullRequestNumbers.size(); + +// Find an element in the set whose value is 3064 +auto it = managedDocsRealm.openPullRequestNumbers.find(3064); + +// Get a copy of the set that exists independent of the managed set +auto openRealmPullRequests = docsRealm.openPullRequestNumbers.detach(); + +``` + +## Sort Lists and Query Results +A sort operation allows you to configure the order in which Realm returns +list objects and query results. You can sort based on one or more properties +of the objects in the list or results collection. Realm only guarantees a +consistent order if you explicitly sort. + +Unlike using [std::sort](https://en.cppreference.com/w/cpp/algorithm/sort), +Realm's sort implementation preserves the lazy loading of objects. It does +not pull the entire set of results or list objects into memory, but only +loads them into memory when you access them. + +To sort, call the `.sort()` function on a list or results set with one or more +sort_descriptors. + +A `sort_descriptor` includes: + +- The desired key path to sort by, as a string. +- A bool to specify sort order, where``true`` is ascending and `false` +is descending. + +In this example, we sort a results set on `priority` in descending order. + +```cpp +auto items = realm.objects(); + +// Sort with `false` returns objects in descending order. +auto itemsSorted = items.sort("priority", false); + +``` + +You can also sort a list or results set by multiple sort descriptors. In +this example, we sort a list property on `assignee` in ascending order, +and then on `priority` in descending order. + +```cpp +auto sortedListProperty = + specificProject.items.sort({{"assignee", true}, {"priority", false}}); + +``` diff --git a/docs-sdk/crud/threading.md b/docs-sdk/crud/threading.md new file mode 100644 index 00000000..95f8d6fd --- /dev/null +++ b/docs-sdk/crud/threading.md @@ -0,0 +1,480 @@ +# Threading - C++ SDK +To create performant apps, developers must write thread-safe and maintainable +multithreaded code that avoids issues like deadlocking and race conditions. +Realm provides tools specifically designed for performant multithreaded apps. + +## Three Rules to Follow +Before exploring Realm's tools for multithreaded apps, you need to +understand and follow these three rules: + +Realm's Multiversion Concurrency Control (MVCC) +architecture eliminates the need to lock for read operations. The values you +read will never be corrupted or in a partially-modified state. You can freely +read from the same Realm file on any thread without the need for locks or +mutexes. Unnecessarily locking would be a performance bottleneck since each +thread might need to wait its turn before reading. + +You can write to a Realm file from any thread, but there can be only one +writer at a time. Consequently, synchronous write transactions block each +other. A synchronous write on the UI thread may result in your app appearing +unresponsive while it waits for a write on a background thread to complete. + +Live objects, collections, and realm instances are **thread-confined**: that +is, they are only valid on the thread on which they were created. Practically +speaking, this means you cannot pass live instances to other threads. However, +Realm offers several mechanisms for sharing objects across +threads. + +## Communication Across Threads +To access the same Realm file from different threads, you must instantiate a +realm instance on every thread that needs access. As long as you specify the same +configuration, all realm instances will map to the same file on disk. + +One of the key rules when working with Realm in a multithreaded +environment is that objects are thread-confined: **you cannot access the +instances of a realm, collection, or object that originated on other threads.** +Realm's Multiversion Concurrency Control (MVCC) +architecture means that there could be many active versions of an object at any +time. Thread-confinement ensures that all instances in that thread are of the +same internal version. + +When you need to communicate across threads, you have several options depending +on your use case: + +- To modify an object on two threads, query +for the object on both threads. +- To react to changes made on any thread, use Realm's +notifications. +- To see changes that happened on another thread in the current thread's realm +instance, refresh your realm instance. +- To share an instance of a realm or specific object with another thread, share +a thread_safe_reference to the realm +instance or object. +- To send a fast, read-only view of the object to other threads, +"freeze" the object. + +### Pass Instances Across Threads +Instances of `realm::realm`, `realm::results`, and `realm::object` are +*thread-confined*. That means you may only use them on the thread where you +created them. + +You can copy thread-confined instances to another thread as follows: + +1. Initialize a thread_safe_reference +with the thread-confined object. +2. Pass the reference to the target thread. +3. Resolve the reference on the target thread. If the referred object is a realm +instance, resolve it by calling `.resolve()`; otherwise, move the reference +to `realm.resolve()`. The returned object is now thread-confined on the +target thread, as if it had been created on the target thread instead of the +original thread. + +> Important: +> You must resolve a `thread_safe_reference` exactly once. Otherwise, +the source realm will remain pinned until the reference gets +deallocated. For this reason, `thread_safe_reference` should be +short-lived. +> + +```cpp +// Put a managed object into a thread safe reference +auto threadSafeItem = + realm::thread_safe_reference{managedItem}; + +// Move the thread safe reference to a background thread +auto thread = + std::thread([threadSafeItem = std::move(threadSafeItem), path]() mutable { + // Open the database again on the background thread + auto backgroundConfig = realm::db_config(); + backgroundConfig.set_path(path); + auto backgroundRealm = realm::db(std::move(backgroundConfig)); + + // Resolve the Item instance via the thread safe + // reference + auto item = backgroundRealm.resolve(std::move(threadSafeItem)); + + // ... use item ... + }); + +// Wait for thread to complete +thread.join(); + +``` + +Another way to work with an object on another thread is to query for it +again on that thread. But if the object does not have a primary +key, it is not trivial to query for it. You can use `thread_safe_reference` +on any object, regardless of whether it has a primary key. + +### Use the Same Realm Across Threads +You cannot share realm instances across threads. + +To use the same Realm file across threads, open a different realm instance on +each thread. As long as you use the same configuration, all Realm +instances will map to the same file on disk. + +### Pass Immutable Copies Across Threads +Live, thread-confined objects work fine in most cases. +However, some apps -- those based on reactive, event +stream-based architectures, for example -- need to send +immutable copies around to many threads for processing +before ultimately ending up on the UI thread. Making a deep +copy every time would be expensive, and Realm does not allow +live instances to be shared across threads. In this case, +you can **freeze** and **thaw** objects, collections, and realms. + +Freezing creates an immutable view of a specific object, +collection, or realm. The frozen object, collection, or realm still +exists on disk, and does not need to be deeply copied when passed around +to other threads. You can freely share the frozen object across threads +without concern for thread issues. When you freeze a realm, its child +objects also become frozen. + +Frozen objects are not live and do not automatically update. +They are effectively snapshots of the object state at the +time of freezing. Thawing an object returns a live version of the frozen +object. + +To freeze a realm, collection, or object, call the `.freeze()` method: + +```cpp +auto realm = realm::db(std::move(config)); + +// Get an immutable copy of the database that can be passed across threads. +auto frozenRealm = realm.freeze(); + +if (frozenRealm.is_frozen()) { + // Do something with the frozen database. + // You may pass a frozen realm, collection, or objects + // across threads. Or you may need to `.thaw()` + // to make it mutable again. +} + +// You can freeze collections. +auto managedItems = realm.objects(); +auto frozenItems = managedItems.freeze(); + +CHECK(frozenItems.is_frozen()); + +// You can read from frozen databases. +auto itemsFromFrozenRealm = + frozenRealm.objects(); + +CHECK(itemsFromFrozenRealm.is_frozen()); + +// You can freeze objects. +auto managedItem = managedItems[0]; +auto frozenItem = managedItem.freeze(); + +CHECK(frozenItem.is_frozen()); + +// Frozen objects have a reference to a frozen realm. +CHECK(frozenItem.get_realm().is_frozen()); + +``` + +When working with frozen objects, an attempt to do any of +the following throws an exception: + +- Opening a write transaction on a frozen realm. +- Modifying a frozen object. +- Adding a change listener to a frozen realm, collection, or object. + +You can use `.is_frozen()` to check if the object is frozen. This is always +thread-safe. + +```cpp +if (frozenRealm.is_frozen()) { + // Do something with the frozen database. + // You may pass a frozen realm, collection, or objects + // across threads. Or you may need to `.thaw()` + // to make it mutable again. +} + +``` + +Frozen objects remain valid as long as the live realm that +spawned them stays open. Therefore, avoid closing the live +realm until all threads are done with the frozen objects. +You can close a frozen realm before the live realm is closed. + +> Important: +> Caching too many frozen objects can have a negative +impact on the realm file size. "Too many" depends on your +specific target device and the size of your Realm +objects. If you need to cache a large number of versions, +consider copying what you need out of the realm instead. +> + +#### Modify a Frozen Object +To modify a frozen object, you must thaw the object. Alternately, you can +query for it on an unfrozen realm, then modify it. Calling `.thaw()` +on a live object, collection, or realm returns itself. + +Thawing an object or collection also thaws the realm it references. + +```cpp +// Read from a frozen database. +auto frozenItems = frozenRealm.objects(); + +// The collection that we pull from the frozen database is also frozen. +CHECK(frozenItems.is_frozen()); + +// Get an individual item from the collection. +auto frozenItem = frozenItems[0]; + +// To modify the item, you must first thaw it. +// You can also thaw collections and realms. +auto thawedItem = frozenItem.thaw(); + +// Check to make sure the item is valid. An object is +// invalidated when it is deleted from its managing database, +// or when its managing realm has invalidate() called on it. +REQUIRE(thawedItem.is_invalidated() == false); + +// Thawing the item also thaws the frozen database it references. +auto thawedRealm = thawedItem.get_realm(); +REQUIRE(thawedRealm.is_frozen() == false); + +// With both the object and its managing database thawed, you +// can safely modify the object. +thawedRealm.write([&] { thawedItem.name = "Save the world"; }); + +``` + +#### Append to a Frozen Collection +When you append to a frozen collection, +you must thaw both the object containing the collection and the object +that you want to append. + +The same rule applies when passing frozen objects across threads. A common +case might be calling a function on a background thread to do some work +instead of blocking the UI. + +#### Append To Collection + +In this example, we query for two objects in a frozen Realm: + +- A `Project` object that has a list property of `Item` objects +- An `Item` object + +We must thaw both objects before we can append the `Item` to +the `items` list collection on the `Project`. If we thaw only the +`Project` object but not the `Item`, Realm throws an error. + +```cpp +// Get frozen objects. +// Here, we're getting them from a frozen database, +// but you might also be passing them across threads. +auto frozenItems = frozenRealm.objects(); + +// The collection that we pull from the frozen database is also frozen. +CHECK(frozenItems.is_frozen()); + +// Get the individual objects we want to work with. +auto specificFrozenItems = frozenItems.where( + [](auto const& item) { return item.name == "Save the cheerleader"; }); +auto frozenProjects = + frozenRealm.objects().where( + [](auto const& project) { + return project.name == "Heroes: Genesis"; + }); +; +auto frozenItem = specificFrozenItems[0]; +auto frozenProject = frozenProjects[0]; + +// Thaw the frozen objects. You must thaw both the object +// you want to append and the object whose collection +// property you want to append to. +auto thawedItem = frozenItem.thaw(); +auto thawedProject = frozenProject.thaw(); + +auto managingRealm = thawedProject.get_realm(); +managingRealm.write([&] { thawedProject.items.push_back(thawedItem); }); + +``` + +#### Models + +```cpp +struct Item { + std::string name; +}; +REALM_SCHEMA(Item, name) + +``` + +```cpp +struct Project { + std::string name; + std::vector items; +}; +REALM_SCHEMA(Project, name, items) + +``` + +## Schedulers (Run Loops) +Some platforms or frameworks automatically set up a **scheduler** (or **run +loop**), which continuously processes events during the lifetime of your +app. The Realm C++ SDK detects and uses schedulers on the following +platforms or frameworks: + +- macOS, iOS, tvOS, watchOS +- Android +- Qt + +Realm uses the scheduler to schedule work. + +If your platform does not have a supported scheduler, or you otherwise want to +use a custom scheduler, you can implement realm::scheduler and pass the instance to the realm::db_config you use to +configure the realm. Realm will use the scheduler you pass to it. + +```cpp + struct MyScheduler : realm::scheduler { + MyScheduler() { + // ... Kick off task processor thread(s) and run until the scheduler + // goes out of scope ... + } + + ~MyScheduler() override { + // ... Call in the processor thread(s) and block until return ... + } + + void invoke(std::function&& task) override { + // ... Add the task to the (lock-free) processor queue ... + } + + [[nodiscard]] bool is_on_thread() const noexcept override { + // ... Return true if the caller is on the same thread as a processor + // thread ... + } + + bool is_same_as(const realm::scheduler* other) const noexcept override { + // ... Compare scheduler instances ... + } + + [[nodiscard]] bool can_invoke() const noexcept override { + // ... Return true if the scheduler can accept tasks ... + } + // ... + }; + + int main() { + // Set up a custom scheduler. + auto scheduler = std::make_shared(); + + // Pass the scheduler instance to the realm configuration. + auto config = realm::db_config{path, scheduler}; + + // Start the program main loop. + auto done = false; + while (!done) { + // This assumes the scheduler is implemented so that it + // continues processing tasks on background threads until + // the scheduler goes out of scope. + + // Handle input here. + // ... + if (shouldQuitProgram) { + done = true; + } + } + } + +``` + +## Refreshing Realms +On any thread controlled by a scheduler or run loop, Realm automatically +refreshes objects at the start of every run loop iteration. Between run loop +iterations, you will be working on the snapshot, so individual methods always +see a consistent view and never have to worry about what happens on other +threads. + +When you initially open a realm on a thread, its state will be the most recent +successful write commit, and it will remain on that version until refreshed. If +a thread is not controlled by a run loop, then the realm.refresh() method must be called manually in order to advance the +transaction to the most recent state. + +```cpp +realm.refresh(); + +``` + +> Note: +> Failing to refresh realms on a regular basis could lead to some transaction +versions becoming "pinned", preventing Realm from reusing the disk space used +by that version and leading to larger file sizes. +> + +## Realm's Threading Model in Depth +Realm provides safe, fast, lock-free, and concurrent access +across threads with its [Multiversion Concurrency +Control (MVCC)](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) +architecture. + +### Compared and Contrasted with Git +If you are familiar with a distributed version control +system like [Git](https://git-scm.com/), you may already +have an intuitive understanding of MVCC. Two fundamental +elements of Git are: + +- Commits, which are atomic writes. +- Branches, which are different versions of the commit history. + +Similarly, Realm has atomically-committed writes in the form +of transactions. Realm also has many different versions of the +history at any given time, like branches. + +Unlike Git, which actively supports distribution and +divergence through forking, a realm only has one true latest +version at any given time and always writes to the head of +that latest version. Realm cannot write to a previous +version. This means your data converges on one +latest version of the truth. + +### Internal Structure +A realm is implemented using a [B+ tree](https://en.wikipedia.org/wiki/B%2B_tree) data structure. The top-level node represents a +version of the realm; child nodes are objects in that +version of the realm. The realm has a pointer to its latest +version, much like how Git has a pointer to its HEAD commit. + +Realm uses a copy-on-write technique to ensure +[isolation](https://en.wikipedia.org/wiki/Isolation_(database_systems)) and +[durability](https://en.wikipedia.org/wiki/Durability_(database_systems)). +When you make changes, Realm copies the relevant part of the +tree for writing. Realm then commits the changes in two +phases: + +- Realm writes changes to disk and verifies success. +- Realm then sets its latest version pointer to point to the newly-written version. + +This two-step commit process guarantees that even if the +write failed partway, the original version is not corrupted +in any way because the changes were made to a copy of the +relevant part of the tree. Likewise, the realm's root +pointer will point to the original version until the new +version is guaranteed to be valid. + +> Example: +> The following diagram illustrates the commit process: +> +> ![Realm copies the relevant part of the tree for writes, then replaces the latest version by updating a pointer.](../../../images/mvcc-diagram.png) +> +> 1. The realm is structured as a tree. The realm has a pointer +to its latest version, V1. +> 2. When writing, Realm creates a new version V2 based on V1. +Realm makes copies of objects for modification (A 1, +C 1), while links to unmodified objects continue to +point to the original versions (B, D). +> 3. After validating the commit, Realm updates the +pointer to the new latest version, V2. Realm then discards +old nodes no longer connected to the tree. +> + +Realm uses zero-copy techniques +like memory mapping to handle data. When you read a value +from the realm, you are virtually looking at the value on +the actual disk, not a copy of it. This is the basis for +live objects. This is also why a realm +head pointer can be set to point to the new version after +the write to disk has been validated. diff --git a/docs-sdk/crud/update.md b/docs-sdk/crud/update.md new file mode 100644 index 00000000..0e05e39d --- /dev/null +++ b/docs-sdk/crud/update.md @@ -0,0 +1,261 @@ +# CRUD - Update - C++ SDK +Updates to Realm Objects must occur within write transactions. For +more information about write transactions, see: Write +Transactions. + +## Update an Object +You can modify properties of a Realm object inside of a write transaction. + +```cpp +// Query for the object you want to update +auto dogs = realm.objects(); +auto dogsNamedMaui = + dogs.where([](auto &dog) { return dog.name == "Maui"; }); +CHECK(dogsNamedMaui.size() >= 1); +// Access an object in the results set. +auto maui = dogsNamedMaui[0]; + +std::cout << "Dog " << maui.name.detach() << " is " << maui.age.detach() + << " years old\n"; + +// Assign a new value to a member of the object in a write transaction +int64_t newAge = 2; +realm.write([&] { maui.age = newAge; }); + +``` + +**Model** + +This example uses the following model: + +```cpp +struct Dog { + std::string name; + int64_t age; +}; +REALM_SCHEMA(Dog, name, age) + +``` + +### Update an Embedded Object Property +To update a property in an embedded object, modify the property in a +write transaction. + +```cpp +auto managedBusinesses = realm.objects(); +auto businessesNamedmyBusiness = managedBusinesses.where( + [](auto &business) { return business.name == "my business"; }); +CHECK(businessesNamedmyBusiness.size() >= 1); +auto myBusiness = businessesNamedmyBusiness[0]; + +realm.write( + [&] { myBusiness.contactDetails->emailAddress = "info@example.com"; }); + +std::cout << "New email address: " + << myBusiness.contactDetails->emailAddress.detach() << "\n"; + +``` + +**Model** + +This example uses the following model: + +```cpp +namespace realm { +struct ContactDetails { + // Because ContactDetails is an embedded object, it cannot have its own _id + // It does not have a lifecycle outside of the top-level object + std::string emailAddress; + std::string phoneNumber; +}; +REALM_EMBEDDED_SCHEMA(ContactDetails, emailAddress, phoneNumber) + +struct Business { + realm::object_id _id; + std::string name; + ContactDetails *contactDetails; +}; +REALM_SCHEMA(Business, _id, name, contactDetails) +} // namespace realm + +``` + +### Overwrite an Embedded Object Property +To overwrite an embedded object, reassign the embedded object property +to the raw pointer of a new instance in a write transaction. + +```cpp +auto businesses = realm.objects(); +auto theBusinesses = businesses.where( + [](auto &business) { return business.name == "my business"; }); +auto theBusiness = theBusinesses[0]; + +realm.write([&] { + auto newContactDetails = realm::ContactDetails{ + .emailAddress = "info@example.com", .phoneNumber = "234-567-8901"}; + // Overwrite the embedded object + theBusiness.contactDetails = &newContactDetails; +}); + +``` + +**Model** + +This example uses the following model: + +```cpp +auto managedBusinesses = realm.objects(); +auto businessesNamedmyBusiness = managedBusinesses.where( + [](auto &business) { return business.name == "my business"; }); +CHECK(businessesNamedmyBusiness.size() >= 1); +auto myBusiness = businessesNamedMyBusiness[0]; + +realm.write( + [&] { myBusiness.contactDetails->emailAddress = "info@example.com"; }); + +std::cout << "New email address: " + << myBusiness.contactDetails->emailAddress.detach() << "\n"; + +``` + +### Update an Inverse Relationship +You can't update an inverse relationship property directly. Instead, an +inverse relationship automatically updates by changing assignment through +its relevant related object. + +In this example, a `Person` object has a to-one relationship to a +`Dog` object, and `Dog` has an inverse relationship to `Person`. The +inverse relationship automatically updates when the `Person` object updates +its `Dog` relationship. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +auto dog = realm::Dog{.name = "Wishbone"}; + +auto [joe] = realm.write([&realm]() { + auto person = + realm::Person{.name = "Joe", .age = 27, .dog = nullptr}; + return realm.insert(std::move(person)); +}); + +realm.write([&dog, joe = &joe]() { joe->dog = &dog; }); + +// After assigning `&dog` to jack's `dog` property, +// the backlink automatically updates to reflect +// the inverse relationship through the dog's `owners` +// property. +CHECK(joe.dog->owners.size() == 1); + +``` + +**Model** + +This example uses the following model: + +```cpp +struct Dog; +struct Person { + realm::primary_key _id; + std::string name; + int64_t age = 0; + Dog* dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) +struct Dog { + realm::primary_key _id; + std::string name; + int64_t age = 0; + linking_objects<&Person::dog> owners; +}; +REALM_SCHEMA(Dog, _id, name, age, owners) + +``` + +### Update a Map Property +You can update a realm map property +as you would a standard C++ [map](https://en.cppreference.com/w/cpp/container/map): + +```cpp +// You can check that a key exists using `find` +auto findTuesday = tommy.locationByDay.find("Tuesday"); +if (findTuesday != tommy.locationByDay.end()) + realm.write([&] { + tommy.locationByDay["Tuesday"] = + realm::Employee::WorkLocation::HOME; + }); +; + +``` + +**Model** + +This example uses the following model: + +```cpp +namespace realm { +struct Employee { + enum class WorkLocation { HOME, OFFICE }; + + int64_t _id; + std::string firstName; + std::string lastName; + std::map locationByDay; +}; +REALM_SCHEMA(Employee, _id, firstName, lastName, locationByDay) +} // namespace realm + +``` + +### Update a Set Property +You can update a set property +in a write transaction. You can `.insert()` elements into the set, `erase()` +elements from a set, or use `std::set` algorithms to mutate sets: + +- [std::set_union](https://en.cppreference.com/w/cpp/algorithm/set_union) +- [std::set_intersection](https://en.cppreference.com/w/cpp/algorithm/set_intersection) +- [std::set_difference](https://en.cppreference.com/w/cpp/algorithm/set_difference) +- [std::set_symmetric_difference](https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference) + +```cpp +// Add elements to the set in a write transaction +realm.write([&] { managedDocsRealm.openPullRequestNumbers.insert(3066); }); +CHECK(managedDocsRealm.openPullRequestNumbers.size() == 4); + +// Use std::set algorithms to update a set +// In this example, use std::set_union to add elements to the set +// 3064 already exists, so it won't be added, but 3065 and 3067 are +// unique values and will be added to the set. +auto newOpenPullRequests = std::set({3064, 3065, 3067}); +realm.write([&] { + std::set_union( + docsRealm.openPullRequestNumbers.begin(), + docsRealm.openPullRequestNumbers.end(), newOpenPullRequests.begin(), + newOpenPullRequests.end(), + std::inserter(managedDocsRealm.openPullRequestNumbers, + managedDocsRealm.openPullRequestNumbers.end())); +}); +CHECK(managedDocsRealm.openPullRequestNumbers.size() == 6); + +// Erase elements from a set +auto it3065 = managedDocsRealm.openPullRequestNumbers.find(3065); +CHECK(it3065 != managedDocsRealm.openPullRequestNumbers.end()); +realm.write([&] { managedDocsRealm.openPullRequestNumbers.erase(it3065); }); + +``` + +**Model** + +This example uses the following model: + +```cpp +namespace realm { +struct Repository { + std::string ownerAndName; + std::set openPullRequestNumbers; +}; +REALM_SCHEMA(Repository, ownerAndName, openPullRequestNumbers) +} // namespace realm + +``` diff --git a/docs-sdk/images/geoboxes-query.png b/docs-sdk/images/geoboxes-query.png new file mode 100644 index 0000000000000000000000000000000000000000..0027f68f7c9ba1d767124aad9a6da1ae7885d51c GIT binary patch literal 17903 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 G@IL?^uC_-2 literal 0 HcmV?d00001 diff --git a/docs-sdk/images/geoboxes.png b/docs-sdk/images/geoboxes.png new file mode 100644 index 0000000000000000000000000000000000000000..d4ebce77a7feff94d6ecbfdf56563aa21c4ddcc2 GIT binary patch literal 10430 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 HF%JA6ST5E? literal 0 HcmV?d00001 diff --git a/docs-sdk/images/geocircles-query.png b/docs-sdk/images/geocircles-query.png new file mode 100644 index 0000000000000000000000000000000000000000..99644c771cc3b408f1c9a9fc97ebfc584eea1084 GIT binary patch literal 29675 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 literal 0 HcmV?d00001 diff --git a/docs-sdk/images/geocircles.png b/docs-sdk/images/geocircles.png new file mode 100644 index 0000000000000000000000000000000000000000..490ba2f6008ec071c4d62f73c7185b3d0e4642ff GIT binary patch literal 22501 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 H;uZG~^@oD2 literal 0 HcmV?d00001 diff --git a/docs-sdk/images/mvcc-diagram.png b/docs-sdk/images/mvcc-diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..adae20b535ff6aff244caeb749200fd82d63d279 GIT binary patch literal 46622 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%0Aplkk+!s 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 W;8oh;DGm!wc3Jky#jFe0Z~q5bLU2d` literal 0 HcmV?d00001 diff --git a/docs-sdk/install.md b/docs-sdk/install.md new file mode 100644 index 00000000..90c1cffe --- /dev/null +++ b/docs-sdk/install.md @@ -0,0 +1,144 @@ +# Install the C++ SDK +Realm SDK for C++ enables client applications written in C++ to access +data stored on devices. This page details how to +install the C++ SDK in your project and get started. + +## Requirements +- Minimum C++ standard: C++17. +- For development on macOS: Xcode 11.x or later. +- For development on Windows: Microsoft Visual C++ (MSVC). +- Otherwise, we recommend git and [CMake](https://cmake.org). + +## Install +> Tip: +> The SDK uses Realm Core database for device data persistence. When you +install the C++ SDK, the package names reflect Realm naming. +> + +#### Swiftpm + +When developing with Xcode, you can use Swift Package Manager (SPM) to +install realm-cpp. + +##### Add Package Dependency +In Xcode, select `File` > `Add Packages...`. + +##### Specify the Repository +Copy and paste the following into the search/input box. + +```sh +https://github.com/realm/realm-cpp +``` + +##### Select the Package Products +Under Package Product, select `realm-cpp-sdk`. Under +Add to Target, select the target you would like to add +the SDK to. For example, the target might be the main executable of +your app. Click Add Package. + +#### Cmake + +You can use CMake with the FetchContent module to manage the SDK and its +dependencies in your C++ project. + +Create or modify your `CMakeLists.txt` in the root directory of your +project: + +1. Add `Include(FetchContent)` to include the FetchContent module +in your project build. +2. Use `FetchContent_Declare` to locate the SDK dependency +and specify the version tag you want to use. +3. Use the `FetchContent_MakeAvailable()` command to check whether +the named dependencies have been populated, and if not, populate them. +4. Finally, `target_link_libraries()` links the SDK dependency to +your target executable. + +To get the most recent version tag, refer to the releases on GitHub: +[realm/realm-cpp](https://github.com/realm/realm-cpp/releases). + +Set the minimum C++ standard to 17 with `set(CMAKE_CXX_STANDARD 17)`. + +In a Windows install, add the required compiler flags listed below. + +```cmake +cmake_minimum_required(VERSION 3.15) + +project(MyDeviceSDKCppProject) + +# Minimum C++ standard +set(CMAKE_CXX_STANDARD 17) + +# In a Windows install, set these compiler flags: +if(MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:preprocessor /bigobj") +endif() + +# Include the FetchContent module so you can download the C++ SDK +Include(FetchContent) + +# Declare the version of the C++ SDK you want to download +FetchContent_Declare( + cpprealm + GIT_REPOSITORY https://github.com/realm/realm-cpp.git + GIT_TAG v1.0.0 +) + +# The MakeAvailable command ensures the named dependencies have been populated +FetchContent_MakeAvailable(cpprealm) + +# Create an executable target called myApp with the source file main.cpp +add_executable(myApp main.cpp) + +target_link_libraries(myApp PRIVATE cpprealm) +``` + +Run CMake in a gitignored directory, such as `build`, to generate the build +configurations that you can then use to compile your app: + +```bash +# build/ is in .gitignore +mkdir build +cd build +cmake .. # Create Makefile by reading the CMakeLists.txt in the parent directory (../) +make # Actually build the app +``` + +You can use CMake to generate more than simple Makefiles by using the `-G` +flag. See the [CMake documentation](https://cmake.org/documentation/) for more +information. + +## Usage +### Include the Header +Make the C++ SDK available in your code by including the +`cpprealm/sdk.hpp` header in the translation unit where you want to use it: + +```cpp +#include <cpprealm/sdk.hpp> + +``` + +## Build an Android App +The C++ SDK supports building Android apps. To build an Android +app: + +- Add `<uses-permission android:name="android.permission.INTERNET" />` to your `AndroidManifest.xml` +- Add the subdirectory of the C++ SDK to your native library's `CMakeLists.txt` +and link it as a target library: `set(CMAKE_CXX_STANDARD 17) +add_subdirectory("realm-cpp") +... +target_link_libraries( + # Specifies the target library. + myapplication + # make sure to link the C++ SDK. + cpprealm +)` +- Ensure that the git submodules are initialized inside of the `realm-cpp` folder before building. +- When instantiating the database or the SDK App, you must pass the `filesDir.path` as the `path` +parameter in the respective constructor or database open template. + +For an example of how to use the C++ SDK in an Android app, refer to +the [Android RealmExample App](https://github.com/realm/realm-cpp/tree/main/examples/Android) +in the `realm-cpp` GitHub repository. + +Specifically, refer to the `MainActivity.kt` & `native-lib.cpp` files +in the Android example app for code examples. diff --git a/docs-sdk/logging.md b/docs-sdk/logging.md new file mode 100644 index 00000000..7e03c6e6 --- /dev/null +++ b/docs-sdk/logging.md @@ -0,0 +1,42 @@ +# Logging - C++ SDK +You can set or change your app's log level to develop or debug your +application. You might want to change the log level to log different +amounts of data depending on the app's environment. + +## Set the Realm Log Level +You can set the level of detail reported by the Realm C++ SDK. Pass a +realm::logger::level +to the `set_default_level_threshold()` member function: + +```cpp +auto logLevel = realm::logger::level::info; +realm::set_default_level_threshold(logLevel); + +``` + +## Customize the Logging Function +To set a custom logger function, create a +realm::logger +and override the virtual `do_log()` member function: + +```cpp +struct MyCustomLogger : realm::logger { + // This could be called from any thread, so may not output visibly to the + // console. Handle output in a queue or other cross-thread context if needed. + void do_log(realm::logger::level level, const std::string &msg) override { + std::cout << "Realm log entry: " << msg << std::endl; + } +}; + +``` + +Then, initialize an instance of the logger and set it as the default logger +for your realm: + +```cpp +auto config = realm::db_config(); +auto thisRealm = realm::db(config); +auto myLogger = std::make_shared<MyCustomLogger>(); +realm::set_default_logger(myLogger); + +``` diff --git a/docs-sdk/model-data.md b/docs-sdk/model-data.md new file mode 100644 index 00000000..fe1b47c6 --- /dev/null +++ b/docs-sdk/model-data.md @@ -0,0 +1,6 @@ +# Model Data - C++ SDK +Use the following pages to learn and reference Realm data modeling concepts and APIs: + +- [Object Types and Schemas](model-data/object-models.md) +- [Supported Data Types](model-data/supported-types.md) +- [Relationships](model-data/relationships.md) diff --git a/docs-sdk/model-data/object-models.md b/docs-sdk/model-data/object-models.md new file mode 100644 index 00000000..2bff527a --- /dev/null +++ b/docs-sdk/model-data/object-models.md @@ -0,0 +1,198 @@ +# Object Models - C++ SDK +Realm SDK applications model data as objects composed of +field-value pairs that each contain one or more supported data types. + +## Object Types and Schemas +Every database object has an *object type* that refers to the object's +class. Objects of the same type share an object schema that defines the properties and relationships of those +objects. + +### Database Schema +A **database schema** is a list of valid object schemas that the database may +contain. Every database object must conform to an object type that's included +in its database's schema. + +When opening a database, you must specify which models are available by +passing the models to the template you use to open the database. Those +models must have schemas, and this list of schemas becomes the database schema. + +If the database already contains data when you open it, the SDK +validates each object to ensure that an object schema was provided for +its type and that it meets all of the constraints specified in the schema. + +For more information about how to open the database, refer to +Configure & Open a Realm - C++ SDK + +### Object Model +Your object model is the core structure that gives the database +information about how to interpret and store the objects in your app. +The C++ SDK object model is a regular C++ class or a struct that contains +a collection of properties. The properties that you want to persist must +use supported data types. Properties +are also the mechanism for establishing relationships between object types. + +When you define your C++ class or struct, you must also provide an +object schema. The schema is a C++ macro that gives the SDK information +about which properties to persist, and what type of database object it +is. + +You must define your SDK object model within the `realm` namespace. + +### Object Schema +A C++ SDK **object schema** maps properties for a specific object type. +The SDK schemas are macros that give the SDK the information it needs to +store and retrieve the objects. A schema must accompany every object model +you want to persist, and it may be one of: + +- `REALM_SCHEMA` +- `REALM_EMBEDDED_SCHEMA` +- `REALM_ASYMMETRIC_SCHEMA` + +You must define the schema and your object model within the `realm` namespace. + +## Define a New Object Type +In the C++ SDK, you can define your models as regular C++ structs or classes. +Provide an Object Schema with the object type name and +the names of any properties that you want to persist to the database. When you +add the object to the database, the SDK ignores any properties that you omit +from the schema. + +You must declare your object and the schema within the `realm` namespace. +You must then use the `realm` namespace when you initialize and perform CRUD +operations with the object. + +```cpp +namespace realm { +struct Dog { + std::string name; + int64_t age; +}; +REALM_SCHEMA(Dog, name, age) + +struct Person { + realm::primary_key<int64_t> _id; + std::string name; + int64_t age; + + // Create relationships by pointing an Object field to another struct or class + Dog *dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) +} // namespace realm + +``` + +> Note: +> Class names are limited to a maximum of 57 UTF-8 characters. +> + +### Specify a Primary Key +You can designate a property as the **primary key** of your object. + +Primary keys allow you to efficiently find, update, and upsert objects. + +Primary keys are subject to the following limitations: + +- You can define only one primary key per object model. +- Primary key values must be unique across all instances of an object +in the database. The C++ SDK throws an error if you try to +insert a duplicate primary key value. +- Primary key values are immutable. To change the primary key value of +an object, you must delete the original object and insert a new object +with a different primary key value. +- Embedded objects cannot define a primary key. + +The C++ SDK supports primary keys of the following types, and their +optional variants: + +- `int64_t` +- `realm::object_id` +- `realm::uuid` +- `std::string` + +Additionally, a required `realm::enum` property can be a primary key, but +`realm::enum` cannot be optional if it is used as a primary key. + +Set a property as a primary key with the `primary_key` template: + +```cpp +struct Person { + realm::primary_key<int64_t> _id; + std::string name; + int64_t age; + + // Create relationships by pointing an Object field to another struct or class + Dog *dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) + +``` + +### Ignore a Property +Your model may include properties that the database does not store. + +The database ignores any properties not included in the Object Schema. + +```cpp +namespace realm { +struct Employee { + realm::primary_key<int64_t> _id; + std::string firstName; + std::string lastName; + + // You can use this property as you would any other member + // Omitting it from the schema means the SDK ignores it + std::string jobTitle_notPersisted; +}; +// The REALM_SCHEMA omits the `jobTitle_notPersisted` property +// The SDK does not store and cannot retrieve a value for this property +REALM_SCHEMA(Employee, _id, firstName, lastName) +} // namespace realm + +``` + +### Define an Embedded Object +An **embedded object** is a special type of object that models complex +data about a specific object. Embedded objects are similar to +relationships, but they provide additional constraints and +map more naturally to the denormalized document model + +The C++ SDK enforces unique ownership constraints that treat each embedded +object as nested data inside of a single, specific parent object. An +embedded object inherits the lifecycle of its parent object and cannot +exist as an independent database object. The SDK automatically deletes +embedded objects if their parent object is deleted or when overwritten +by a new embedded object instance. + +You can declare an object as an embedded object +that does not have a lifecycle independent of the object in which it +is embedded. This differs from a to-one +or to-many relationship, in which the +related objects have independent lifecycles. + +Provide a `REALM_EMBEDDED_SCHEMA` with the struct or class name and the +names of any properties that you want the database to persist. + +Define a property as an embedded object on the parent object by setting +a pointer to the embedded object's type. + +```cpp +namespace realm { +struct ContactDetails { + // Because ContactDetails is an embedded object, it cannot have its own _id + // It does not have a lifecycle outside of the top-level object + std::string emailAddress; + std::string phoneNumber; +}; +REALM_EMBEDDED_SCHEMA(ContactDetails, emailAddress, phoneNumber) + +struct Business { + realm::object_id _id; + std::string name; + ContactDetails *contactDetails; +}; +REALM_SCHEMA(Business, _id, name, contactDetails) +} // namespace realm + +``` + diff --git a/docs-sdk/model-data/relationships.md b/docs-sdk/model-data/relationships.md new file mode 100644 index 00000000..92bab0c7 --- /dev/null +++ b/docs-sdk/model-data/relationships.md @@ -0,0 +1,124 @@ +# Relationships - C++ SDK +Realm doesn't use bridge tables or explicit joins to define +relationships as you would in a relational database. Realm +handles relationships through embedded objects or reference properties to +other Realm objects. You read from and write to these +properties directly. This makes querying relationships as performant as +querying against any other property. + +## Relationship Types +Realm supports **to-one**, **to-many**, and **inverse** +relationships. Realm also provides a special type of object, called an +embedded object, that is conceptually +similar to a relationship but provides additional constraints. + +### To-One Relationship +A **to-one** relationship means that an object relates to one other object. +You define a to-one relationship for an object type in its object +model. Specify a property where the type is the related Realm +object type. For example, a dog might have a to-one relationship with +a favorite toy. + +### To-Many Relationship +A **to-many** relationship means that an object relates to more than one +other object. In Realm, a to-many relationship is a list of +references to other objects. For example, a person might have many dogs. + +You can represent a to-many relationship between two Realm +types as a list, map, or a set. Lists, maps, and sets are mutable: within +a write transaction, you can add and remove elements to and from these +collection types. Lists, maps, and sets are not associated with a query +and are declared as a property of the object model. + +### Inverse Relationship +Relationship definitions in Realm are unidirectional. An +**inverse relationship** links an object back to an object that refers +to it. + +An inverse relationship property is an automatic backlink relationship. +Realm automatically updates implicit relationships whenever an object is +added or removed in a corresponding to-many list or to-one relationship +property. You cannot manually set the value of an inverse relationship +property. + +## Declare Relationship Properties + +### Define a To-One Relationship +A **to-one** relationship maps one property to a single instance of +another object type. For example, you can model a dog having at most one +favorite toy as a to-one relationship. + +Setting a relationship field to null removes the connection between objects. +Realm does not delete the referenced object, though, unless it is +an embedded object. + +> Important: +> When you declare a to-one relationship in your object model, it must +be an optional property. If you try to make a to-one relationship +required, Realm throws an exception at runtime. +> + +```cpp +struct FavoriteToy { + realm::primary_key<realm::uuid> _id; + std::string name; +}; +REALM_SCHEMA(FavoriteToy, _id, name) + +struct Dog { + realm::primary_key<realm::uuid> _id; + std::string name; + int64_t age; + + // Define a relationship as a link to another SDK object + FavoriteToy* favoriteToy; +}; +REALM_SCHEMA(Dog, _id, name, age, favoriteToy) + +``` + +### Define a To-Many Relationship +A **to-many** relationship maps one property to zero or more instances +of another object type. For example, you can model a company having any +number of employees as a to-many relationship. + +```cpp +struct Company { + int64_t _id; + std::string name; + // To-many relationships are a list, represented here as a + // vector container whose value type is the SDK object + // type that the list field links to. + std::vector<Employee*> employees; +}; +REALM_SCHEMA(Company, _id, name, employees) + +``` + +### Define an Inverse Relationship +To define an inverse relationship, use `linking_objects` in your object +model. The `linking_objects` definition specifies the object type and +property name of the relationship that it inverts. + +In this example, we define a `Person` having a to-one relationship with +a `Dog`. The `Dog` has an inverse relationship to any `Person` +objects through its `owners` property. + +```cpp +struct Dog; +struct Person { + realm::primary_key<int64_t> _id; + std::string name; + int64_t age = 0; + Dog* dog; +}; +REALM_SCHEMA(Person, _id, name, age, dog) +struct Dog { + realm::primary_key<int64_t> _id; + std::string name; + int64_t age = 0; + linking_objects<&Person::dog> owners; +}; +REALM_SCHEMA(Dog, _id, name, age, owners) + +``` diff --git a/docs-sdk/model-data/supported-types.md b/docs-sdk/model-data/supported-types.md new file mode 100644 index 00000000..f2ae5c00 --- /dev/null +++ b/docs-sdk/model-data/supported-types.md @@ -0,0 +1,160 @@ +# Supported Types - C++ SDK +The Realm C++ SDK currently supports these property types. + +Optionals use the class template +[std::optional](https://en.cppreference.com/w/cpp/utility/optional). + +## Property Cheat Sheet +You can use the following types to define your object model +properties. + +|Type|Required|Optional| +| --- | --- | --- | +|Bool|`bool boolName;`|`std::optional<bool> optBoolName;`| +|Int64|`int64_t intName;`|`std::optional<int64_t> optIntName;`| +|Double|`double doubleName;`|`std::optional<double> optDoubleName;`| +|String|`std::string stringName;`|`std::optional<std::string> optStringName;`| +|Enum|`Enum enumName;`|`std::optional<Enum> optEnumName;`| +|Binary Data|`std::vector<std::uint8_t> binaryDataName;`|`std::optional<std::vector<std::uint8_t>> optBinaryDataName;`| +|Date|`std::chrono::time_point<std::chrono::system_clock> dateName;`|`std::optional<std::chrono::time_point<std::chrono::system_clock>> optDateName;`| +|Decimal128|`realm::decimal128 decimal128Name;`|`std::optional<realm::decimal128> optDecimal128Name;`| +|UUID|`realm::uuid uuidName;`|`std::optional<realm::uuid> optUuidName;`| +|Object ID|`realm::object_id objectIdName;`|`std::optional<realm::object_id> optObjectIdName;`| +|Mixed Data Type|`realm::mixed mixedName;`|N/A| +|Map|`std::map<std::string, SomeType> mapName;`|N/A| +|List|`std::vector<SomeType> listTypeName;`|N/A| +|Set|`std::set<SomeType> setTypeName;`|N/A| +|User-defined Object|N/A|`MyClass* opt_obj_name;`| +|User-defined Embedded Object|N/A|`MyEmbeddedClass* opt_embedded_object_name;`| + +### Supported Type Implementation Details +Some of the supported types above are aliases for: + +- `mixed`: A union-like object that can represent a value any of the +supported types. It is implemented using the class template +[std::variant](https://en.cppreference.com/w/cpp/utility/variant). +This implementation means that a `mixed` property holds a value of +one of its alternative types, or in the case of error - no value. +- For dates, use the [chrono library](https://en.cppreference.com/w/cpp/chrono) +to store a `time_point` relative to the `system_clock`: +`<std::chrono::time_point<std::chrono::system_clock>>` + +## Map/Dictionary +The +Map +is an associative array that contains key-value pairs with unique keys. + +You can declare a Map as a property of an object: + +```cpp +namespace realm { +struct Dog { + std::string name; + std::map<std::string, std::string> favoriteParkByCity; +}; +REALM_SCHEMA(Dog, name, favoriteParkByCity) +} // namespace realm + +``` + +String is the only supported type for a map key, but map values can be: + +- Required versions of any of the SDK's supported data types +- Optional user-defined object links +- Optional embedded objects + +Realm disallows the use of `.` or `$` characters in map keys. +You can use percent encoding and decoding to store a map key that contains +one of these disallowed characters. + +```cpp +// Percent encode . or $ characters to use them in map keys +auto mapKey = "Monday.Morning"; +auto encodedMapKey = "Monday%2EMorning"; + +``` + +## Collection Types +Realm has several types to represent groups of objects, +which we call **collections**. A collection is an object that contains +zero or more instances of one Realm type. Realm collections are **homogenous**: +all objects in a collection are of the same type. + +You can filter and sort any collection using Realm's +query engine. Collections are +live, so they always reflect the current state +of the realm instance on the current thread. You can also +listen for changes in the collection by subscribing to collection +notifications. + +### Results +The C++ SDK Results +collection is a type representing objects retrieved from queries. A +`Results` collection represents the lazily-evaluated results of a +query operation. Results are immutable: you cannot add or remove elements +to or from the results collection. Results have an associated query that +determines their contents. + +For more information, refer to the Read documentation. + +### Set +The C++ SDK set collection represents a +to-many relationship containing +distinct values. A C++ SDK set supports the following types (and their +optional versions): + +- Binary Data +- Bool +- Double +- Date +- Int64 +- Mixed +- ObjectId +- Object +- String +- UUID + +Like the C++ [std::set](https://en.cppreference.com/w/cpp/container/set), +the C++ SDK set is a generic type that is parameterized on the type it stores. + +You can only call set mutation methods during a write transaction. You can +register a change listener on a mutable set. + +### Collections as Properties +The C++ SDK also offers several collection types you can use as properties +in your data model: + +1. List, a type representing +to-many relationships in models. +2. Set, +a type representing to-many relationships +in models where values are unique. +3. linking_objects, a type +representing inverse relationships in models. +4. Map, +a type representing an associative array of key-value pairs with unique keys. + +### Collections are Live +Like live objects, Realm collections +are usually **live**: + +- Live results collections always reflect the current results of the associated query. +- Live lists always reflect the current state of the relationship on the realm instance. + +The one case when a collection is **not** live is when the collection is +unmanaged. For example, a List property of a Realm object that has not +been added to a realm yet or that has been moved from a realm is not live. + +Combined with collection notifications, live collections enable +clean, reactive code. For example, suppose your view displays the +results of a query. You can keep a reference to the results collection +in your view code, then read the results collection as needed without +having to refresh it or validate that it is up-to-date. + +> Important: +> Since results update themselves automatically, do not +store the positional index of an object in the collection +or the count of objects in a collection. The stored index +or count value could be outdated by the time you use +it. +> diff --git a/docs-sdk/quick-start.md b/docs-sdk/quick-start.md new file mode 100644 index 00000000..f0ddc105 --- /dev/null +++ b/docs-sdk/quick-start.md @@ -0,0 +1,117 @@ +# Quick Start - C++ SDK +This Quick Start demonstrates how to use Realm with the Realm C++ SDK. +Before you begin, ensure you have Installed the C++ SDK. + +## Import Realm +Make the Realm C++ SDK available in your code by including the +`cpprealm/sdk.hpp` header in the translation unit where you want to use it: + +```cpp +#include <cpprealm/sdk.hpp> + +``` + +## Define Your Object Model +You can define your object model directly in code. + +```cpp +namespace realm { +struct Todo { + realm::primary_key<realm::object_id> _id{realm::object_id::generate()}; + std::string name; + std::string status; +}; +REALM_SCHEMA(Todo, _id, name, status); +} // namespace realm + +``` + +## Open a Realm +When you open a realm, you must specify a db_config. You can +optionally open a realm at a specific path. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +``` + +For more information, see: Configure and Open a Realm. + +## Create, Read, Update, and Delete Objects +Once you have opened a realm, you can modify it and its objects in a write transaction +block. + +To instantiate a new Todo object and add it to the realm in a write block: + +```cpp +auto todo = realm::Todo{.name = "Create my first todo item", + .status = "In Progress"}; + +realm.write([&] { realm.add(std::move(todo)); }); + +``` + +You can retrieve a live results collection of +all todos in the realm: + +```cpp +auto todos = realm.objects<realm::Todo>(); + +``` + +You can also filter that collection using where: + +```cpp +auto todosInProgress = todos.where( + [](auto const& todo) { return todo.status == "In Progress"; }); + +``` + +To modify a todo, update its properties in a write transaction block: + +```cpp +auto todoToUpdate = todosInProgress[0]; +realm.write([&] { todoToUpdate.status = "Complete"; }); + +``` + +Finally, you can delete a todo: + +```cpp +realm.write([&] { realm.remove(specificTodo); }); + +``` + +## Watch for Changes +You can watch an object for changes with the `observe` method. + +```cpp +auto token = specificTodo.observe([&](auto&& change) { + try { + if (change.error) { + rethrow_exception(change.error); + } + if (change.is_deleted) { + std::cout << "The object was deleted.\n"; + } else { + for (auto& propertyChange : change.property_changes) { + std::cout << "The object's " << propertyChange.name + << " property has changed.\n"; + } + } + } catch (std::exception const& e) { + std::cerr << "Error: " << e.what() << "\n"; + } +}); + +``` + +## Close a Realm +To close a realm and release all underlying resources, call `db::close()`. +Closing the database invalidates any remaining objects. + +```cpp +realm.close(); + +``` diff --git a/docs-sdk/react-to-changes.md b/docs-sdk/react-to-changes.md new file mode 100644 index 00000000..9c972d9f --- /dev/null +++ b/docs-sdk/react-to-changes.md @@ -0,0 +1,262 @@ +# React to Changes - C++ SDK +All Realm objects are **live objects**, which means they +automatically update whenever they're modified. Realm emits a +notification event whenever any property changes. You can register a +notification handler to listen for these notification events, and update +your UI with the latest data. + +## Register an Object Change Listener +You can register a notification handler on a specific object +within a realm. Realm notifies your handler: + +- When the object is deleted. +- When any of the object's properties change. + +```cpp +auto token = object.observe([&](auto&& change) { ... } +``` + +The handler receives an object_change +object that contains information about the changes, such as whether the +object was deleted. It may include a list +of PropertyChange +objects that contain information about what fields changed, the new values +of those fields (except on List properties), and potentially the old values +of the fields. + +```cpp +if (change.error) { + rethrow_exception(change.error); +} +if (change.is_deleted) { + std::cout << "The object was deleted.\n"; +} else { + for (auto& propertyChange : change.property_changes) { + std::cout << "The object's " << propertyChange.name + << " property has changed.\n"; + auto newPropertyValue = + std::get<std::string>(*propertyChange.new_value); + std::cout << "The new value is " << newPropertyValue << "\n"; + } +} + +``` + +When you make changes, refresh() the +realm to emit a notification. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +// Create an object and move it into the database. +auto dog = realm::Dog{.name = "Max"}; +realm.write([&] { realm.add(std::move(dog)); }); + +auto dogs = realm.objects<realm::Dog>(); +auto specificDog = dogs[0]; +// Set up the listener & observe object notifications. +auto token = specificDog.observe([&](auto&& change) { + try { + if (change.error) { + rethrow_exception(change.error); + } + if (change.is_deleted) { + std::cout << "The object was deleted.\n"; + } else { + for (auto& propertyChange : change.property_changes) { + std::cout << "The object's " << propertyChange.name + << " property has changed.\n"; + auto newPropertyValue = + std::get<std::string>(*propertyChange.new_value); + std::cout << "The new value is " << newPropertyValue << "\n"; + } + } + } catch (std::exception const& e) { + std::cerr << "Error: " << e.what() << "\n"; + } +}); + +// Update the dog's name to see the effect. +realm.write([&] { specificDog.name = "Wolfie"; }); + +// Deleting the object triggers a delete notification. +realm.write([&] { realm.remove(specificDog); }); + +// Refresh the database after the change to trigger the notification. +realm.refresh(); + +// Unregister the token when done observing. +token.unregister(); + +``` + +## Register a Collection Change Listener +You can register a notification handler on a collection. A collection is +a list, map, or set property that can contain any supported data type, including primitives or other objects. + +Realm notifies your handler whenever a write transaction +removes, adds, or changes objects in the collection. + +Notifications describe the changes since the prior notification with +three lists of indices: the indices of the objects that were removed, +inserted, and modified. + +> Important: +> In collection notification handlers, always apply changes +in the following order: deletions, insertions, then +modifications. Handling insertions before deletions may +result in unexpected behavior. +> + +Collection notifications provide a collection_change +struct that reports the index of the objects that are removed, added, or +modified. It can also notify you if the collection was deleted. + +In this example, the `Person` object has a list of `Dog` objects as a property: + +```cpp +struct Person { + std::string name; + std::vector<Dog*> dogs; +}; +REALM_SCHEMA(Person, name, dogs) + +``` + +Removing a dog, adding a new dog, or modifying a dog triggers the notification +handler: + +```cpp +// Set up the listener & observe a collection. +auto token = person.dogs.observe([&](auto&& changes) { + if (changes.collection_root_was_deleted) { + std::cout << "The collection was deleted.\n"; + } else { + // Handle deletions, then insertions, then modifications. + for (auto& collectionChange : changes.deletions) { + std::cout << "The object at index " << std::to_string(collectionChange) + << " was removed\n"; + } + for (auto& collectionChange : changes.insertions) { + std::cout << "The object at index " << std::to_string(collectionChange) + << " was inserted\n"; + } + for (auto& collectionChange : changes.modifications) { + std::cout << "The object at index " << std::to_string(collectionChange) + << " was modified\n"; + } + } +}); + +// Remove an object from the collection, and then add an object to see +// deletions and insertions. +realm.write([&] { + person.dogs.clear(); + person.dogs.push_back(&dog2); +}); + +// Modify an object to see a modification. +realm.write([&] { dog2.age = 2; }); + +// Refresh the realm after the change to trigger the notification. +realm.refresh(); + +// Unregister the token when done observing. +token.unregister(); + +``` + +## Register a Results Collection Change Listener +You can register a notification handler on a results collection. + +Realm notifies your handler whenever a write transaction +removes, adds, or changes objects in the collection. + +Notifications describe the changes since the prior notification with +three lists of indices: the indices of the objects that were deleted, +inserted, and modified. + +> Important: +> In collection notification handlers, always apply changes +in the following order: deletions, insertions, then +modifications. Handling insertions before deletions may +result in unexpected behavior. +> + +Results collection notifications provide a results_change struct that +reports the index of the objects that are deleted, added, or modified. +It can also notify you if the collection was deleted. + +```cpp +// Get a results collection to observe +auto dogs = realm.objects<realm::Dog>(); +// Set up the listener & observe results notifications. +auto token = dogs.observe([&](auto&& changes) { + try { + if (changes.collection_root_was_deleted) { + std::cout << "The collection was deleted.\n"; + } else { + // Handle deletions, then insertions, then modifications. + for (auto& resultsChange : changes.deletions) { + std::cout << "The object at index " << std::to_string(resultsChange) + << " was deleted\n"; + } + for (auto& resultsChange : changes.insertions) { + std::cout << "The object at index " << std::to_string(resultsChange) + << " was inserted\n"; + } + for (auto& resultsChange : changes.modifications) { + std::cout << "The object at index " << std::to_string(resultsChange) + << " was modified\n"; + } + } + } catch (std::exception const& e) { + std::cerr << "Error: " << e.what() << "\n"; + } +}); + +// Delete and then add an object to see deletions and insertions. +realm.write([&] { + realm.remove(firstDog); + realm.add(std::move(dog2)); +}); + +// Modify an object to see a modification. +realm.write([&] { dog2.age = 2; }); + +// Refresh the database after the change to trigger the notification. +realm.refresh(); + +// Unregister the token when done observing. +token.unregister(); + +``` + +## Stop Watching for Changes +Observation stops when the token returned by an `observe` call becomes +invalid. You can explicitly invalidate a token by calling its +`unregister()` member function. + +```cpp +// Unregister the token when done observing. +token.unregister(); + +``` + +> Important: +> Notifications stop when the token's destructor is called. For example, +if the token is in a local variable that goes out of scope. You can +use `std::move` to transfer the token to a variable in a different +scope. +> + +## Change Notification Limits +Changes in nested documents deeper than four levels down do not trigger +change notifications. + +If you have a data structure where you need to listen for changes five +levels down or deeper, workarounds include: + +- Refactor the schema to reduce nesting. +- Add something like "push-to-refresh" to enable users to manually refresh data. diff --git a/docs-sdk/realm-files.md b/docs-sdk/realm-files.md new file mode 100644 index 00000000..7cb36cbf --- /dev/null +++ b/docs-sdk/realm-files.md @@ -0,0 +1,6 @@ +# Work with Realm Files - C++ SDK +Use the following pages to learn and reference Realm database concepts and APIs: + +- [Configure & Open a Realm](realm-files/configure-and-open-a-realm.md) +- [Reduce Realm File Size](realm-files/compact-realm.md) +- [Encrypt a Realm](realm-files/encrypt-a-realm.md) diff --git a/docs-sdk/realm-files/compact-realm.md b/docs-sdk/realm-files/compact-realm.md new file mode 100644 index 00000000..94be400f --- /dev/null +++ b/docs-sdk/realm-files/compact-realm.md @@ -0,0 +1,82 @@ +# Reduce Realm File Size - C++ SDK +Over time, the storage space used by Realm might become fragmented +and take up more space than necessary. To rearrange the internal storage and +potentially reduce the file size, the realm file needs to be compacted. + +Realm's default behavior is to automatically compact a realm file +to prevent it from growing too large. You can use manual compaction strategies when +automatic compaction is not sufficient for your use case. + +## Automatic Compaction +The SDK automatically compacts Realm files in the background by continuously reallocating data +within the file and removing unused file space. Automatic compaction is sufficient for minimizing the Realm file size +for most applications. + +Automatic compaction begins when the size of unused space in the file is more than twice the size of user +data in the file. Automatic compaction only takes place when +the file is not being accessed. + +## Manual Compaction Options +Manual compaction can be used for applications that require stricter +management of file size. + +Realm manual compaction works by: + +1. Reading the entire contents of the realm file +2. Writing the contents to a new file at a different location +3. Replacing the original file + +If the file contains a lot of data, this can be an expensive operation. + +Use the +should_compact_on_launch() +method on the database configuration to attempt to compact the database. +Specify conditions to execute this method, such as: + +- The size of the file on disk +- How much free space the file contains + +The following example shows setting the conditions to compact a realm if the +file is above 100 MB and 50% or less of the space in the realm file is used. + +```cpp +// Create a database configuration. +auto config = realm::db_config(); + +config.should_compact_on_launch([&](uint64_t totalBytes, uint64_t usedBytes) { + // totalBytes refers to the size of the file on disk in bytes (data + free + // space). usedBytes refers to the number of bytes used by data in the file + // Compact if the file is over 100MB in size and less than 50% 'used' + auto oneHundredMB = 100 * 1024 * 1024; + return (totalBytes > oneHundredMB) && (usedBytes / totalBytes) < 0.5; +}); + +// The database is compacted on the first open if the configuration block +// conditions were met. +auto realm = realm::db(config); + +``` + +### Tips for Manually Compacting a Realm +Manually compacting a realm can be a resource-intensive operation. +Your application should not compact every time you open +a realm. Instead, try to optimize compacting so your application does +it just often enough to prevent the file size from growing too large. +If your application runs in a resource-constrained environment, +you may want to compact when you reach a certain file size or when the +file size negatively impacts performance. + +These recommendations can help you start optimizing compaction for your +application: + +- Set the max file size to a multiple of your average realm state +size. If your average realm state size is 10MB, you might set the max +file size to 20MB or 40MB, depending on expected usage and device +constraints. +- As a starting point, compact realms when more than 50% of the realm file +size is no longer in use. Divide the currently used bytes by the total +file size to determine the percentage of space that is currently used. +Then, check for that to be less than 50%. This means that greater than +50% of your realm file size is unused space, and it is a good time to +compact. After experimentation, you may find a different percentage +works best for your application. diff --git a/docs-sdk/realm-files/configure-and-open-a-realm.md b/docs-sdk/realm-files/configure-and-open-a-realm.md new file mode 100644 index 00000000..7468568e --- /dev/null +++ b/docs-sdk/realm-files/configure-and-open-a-realm.md @@ -0,0 +1,129 @@ +# Configure & Open a Realm - C++ SDK +A **realm** is the core data structure used to organize data in +Realm. A realm is a collection of the objects that you use +in your application, called Realm objects, as well as additional metadata +that describe the objects. + +When opening a realm, you must specify a db_config. +The `db_config` may contain information such as: + +- An optional path where the realm is stored on device +- An optional list of models that the realm should manage +- An optional scheduler if you need to customize the run loop + +You can use the default `db_config` constructor if you do not need +to specify a realm file path or other +configuration details. + +## Realm Files +Realm stores a binary encoded version of every object and type in a +realm in a single `.realm` file. The file is located at a specific +path that you can define when you open the realm. +You can open, view, and edit the contents of these files with +. + +### Auxiliary Files +The SDK creates additional files for each realm: + +- **realm files**, suffixed with "realm", e.g. default.realm: +contain object data. +- **lock files**, suffixed with "lock", e.g. default.realm.lock: +keep track of which versions of data in a realm are +actively in use. This prevents realm from reclaiming storage space +that is still used by a client application. +- **note files**, suffixed with "note", e.g. default.realm.note: +enable inter-thread and inter-process notifications. +- **management files**, suffixed with "management", e.g. default.realm.management: +internal state management. + +### Open the Default Realm +Opening a realm without specifying an optional path opens the default realm +in the current directory. + +When opening a realm, the C++ SDK can automatically infer which +models are available in the project. + +```cpp +auto config = realm::db_config(); +auto realm = realm::db(std::move(config)); + +``` + +> Tip: +> When building an Android app that uses the Realm C++ SDK, +you must pass the `filesDir.path` to the `path` parameter in the +db_config +constructor. For more information, refer to: Build an Android App. +> + +### Open a Realm at a File Path +You can use `set_path()` to specify a path for the `db_config` +to use when opening the realm. + +```cpp +auto relative_realm_path_directory = "custom_path_directory/"; +std::filesystem::create_directories(relative_realm_path_directory); +// Construct a path +std::filesystem::path path = + std::filesystem::current_path().append(relative_realm_path_directory); +// Add a name for the database file +path = path.append("employee_objects"); +// Add the .realm extension +path = path.replace_extension("realm"); +// Set the path on the config, and open the database at the path +auto config = realm::db_config(); +config.set_path(path); +auto realmInstance = realm::db(std::move(config)); + +``` + +> Tip: +> When building an Android app that uses the Realm C++ SDK, +you must pass the `filesDir.path` as the `path` parameter in the +db_config +constructor. For more information, refer to: Build an Android App. +> + +## Provide a Subset of Models to a Realm +> Tip: +> Some applications have tight constraints on their memory footprints. +To optimize your realm memory usage for low-memory environments, open the +realm with a subset of models. +> + +By default, the C++ SDK automatically adds all object types that have a +Object Schema in your executable to your +Database Schema. + +However, if you want the realm to manage only a subset of models, you +can specify those models by passing them into the template parameter list +of the `realm::open()` function. + +``` +auto config = realm::db_config(); +auto realm = realm::open<realm::Dog>(std::move(config)); + +``` + +## Close a Realm +To avoid memory leaks, close the database when you're done using it. Closing +the database invalidates any remaining objects. Close the database with +`db::close()`. + +```cpp +// Create a database configuration. +auto config = realm::db_config(); +auto realm = realm::db(config); + +// Use the database... + +// ... later, close it. +realm.close(); + +// You can confirm that the database is closed if needed. +CHECK(realm.is_closed()); + +// Objects from the database become invalidated when you close the database. +CHECK(specificDog.is_invalidated()); + +``` diff --git a/docs-sdk/realm-files/encrypt-a-realm.md b/docs-sdk/realm-files/encrypt-a-realm.md new file mode 100644 index 00000000..a2c78569 --- /dev/null +++ b/docs-sdk/realm-files/encrypt-a-realm.md @@ -0,0 +1,60 @@ +# Encrypt a Realm - C++ SDK +You can encrypt the realm file on disk with AES-256 + +SHA-2 by supplying a 64-byte encryption key when opening a +realm. + +Realm transparently encrypts and decrypts data with standard +[AES-256 encryption](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) using the +first 256 bits of the given 512-bit encryption key. Realm +uses the other 256 bits of the 512-bit encryption key to validate +integrity using a [hash-based message authentication code +(HMAC)](https://en.wikipedia.org/wiki/HMAC). + +> Warning: +> Do not use cryptographically-weak hashes for realm encryption keys. +For optimal security, we recommend generating random rather than derived +encryption keys. +> + +Encrypt a realm by calling the `set_encryption_key()` function on +your db_config: + +```cpp +// Check if we already have a key stored in the platform's secure storage. +// If we don't, generate a new one. +// Use your preferred method to generate a key. This example key is +// NOT representative of a secure encryption key. It only exists to +// illustrate the form your key might take. +std::array<char, 64> exampleKey = { + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, + 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0}; + +// Store the key securely to be used next time we want to open the database. +// We don't illustrate this here because it varies depending on the platform. + +// Create a database configuration. +auto config = realm::db_config(); +// Set the encryption key in your config. +config.set_encryption_key(exampleKey); + +// Open or create a database with the config containing the encryption key. +auto realm = realm::db(config); + +``` + +> Tip: +> The C++ SDK does not yet support encrypting a realm that already +exists on device. You must encrypt the realm the first time you open it. +> + +## Store & Reuse Keys +You **must** pass the same encryption key every time you open the encrypted realm. +If you don't provide a key or specify the wrong key for an encrypted +realm, the Realm SDK throws an error. + +Apps should store the encryption key securely on the device so that other +apps cannot read the key. + +## Performance Impact +Reads and writes on encrypted realms can be up to 10% slower than unencrypted realms. From a12a969619f713e77406b14caca4431e265b01e2 Mon Sep 17 00:00:00 2001 From: cbullinger <cory.bullinger@mongodb.com> Date: Tue, 9 Sep 2025 12:38:49 -0400 Subject: [PATCH 2/3] Remove links to SDK docs from main README (cherry picked from commit aec34f67b6c7c14eeaaccdd70da5ca7734cf85dd) --- README.md | 4 ++-- docs-sdk/cpp.md => docs/README.md | 0 {docs-sdk => docs/guides}/crud.md | 0 {docs-sdk => docs/guides}/crud/create.md | 0 {docs-sdk => docs/guides}/crud/delete.md | 0 {docs-sdk => docs/guides}/crud/filter-data.md | 0 {docs-sdk => docs/guides}/crud/read.md | 0 {docs-sdk => docs/guides}/crud/threading.md | 0 {docs-sdk => docs/guides}/crud/update.md | 0 {docs-sdk => docs/guides}/images/geoboxes-query.png | Bin {docs-sdk => docs/guides}/images/geoboxes.png | Bin .../guides}/images/geocircles-query.png | Bin {docs-sdk => docs/guides}/images/geocircles.png | Bin {docs-sdk => docs/guides}/images/geopoints.png | Bin .../guides}/images/geopolygons-query.png | Bin {docs-sdk => docs/guides}/images/geopolygons.png | Bin {docs-sdk => docs/guides}/images/mvcc-diagram.png | Bin {docs-sdk => docs/guides}/install.md | 0 {docs-sdk => docs/guides}/logging.md | 0 {docs-sdk => docs/guides}/model-data.md | 0 .../guides}/model-data/object-models.md | 0 .../guides}/model-data/relationships.md | 0 .../guides}/model-data/supported-types.md | 0 {docs-sdk => docs/guides}/quick-start.md | 0 {docs-sdk => docs/guides}/react-to-changes.md | 0 {docs-sdk => docs/guides}/realm-files.md | 0 .../guides}/realm-files/compact-realm.md | 0 .../realm-files/configure-and-open-a-realm.md | 0 .../guides}/realm-files/encrypt-a-realm.md | 0 29 files changed, 2 insertions(+), 2 deletions(-) rename docs-sdk/cpp.md => docs/README.md (100%) rename {docs-sdk => docs/guides}/crud.md (100%) rename {docs-sdk => docs/guides}/crud/create.md (100%) rename {docs-sdk => docs/guides}/crud/delete.md (100%) rename {docs-sdk => docs/guides}/crud/filter-data.md (100%) rename {docs-sdk => docs/guides}/crud/read.md (100%) rename {docs-sdk => docs/guides}/crud/threading.md (100%) rename {docs-sdk => docs/guides}/crud/update.md (100%) rename {docs-sdk => docs/guides}/images/geoboxes-query.png (100%) rename {docs-sdk => docs/guides}/images/geoboxes.png (100%) rename {docs-sdk => docs/guides}/images/geocircles-query.png (100%) rename {docs-sdk => docs/guides}/images/geocircles.png (100%) rename {docs-sdk => docs/guides}/images/geopoints.png (100%) rename {docs-sdk => docs/guides}/images/geopolygons-query.png (100%) rename {docs-sdk => docs/guides}/images/geopolygons.png (100%) rename {docs-sdk => docs/guides}/images/mvcc-diagram.png (100%) rename {docs-sdk => docs/guides}/install.md (100%) rename {docs-sdk => docs/guides}/logging.md (100%) rename {docs-sdk => docs/guides}/model-data.md (100%) rename {docs-sdk => docs/guides}/model-data/object-models.md (100%) rename {docs-sdk => docs/guides}/model-data/relationships.md (100%) rename {docs-sdk => docs/guides}/model-data/supported-types.md (100%) rename {docs-sdk => docs/guides}/quick-start.md (100%) rename {docs-sdk => docs/guides}/react-to-changes.md (100%) rename {docs-sdk => docs/guides}/realm-files.md (100%) rename {docs-sdk => docs/guides}/realm-files/compact-realm.md (100%) rename {docs-sdk => docs/guides}/realm-files/configure-and-open-a-realm.md (100%) rename {docs-sdk => docs/guides}/realm-files/encrypt-a-realm.md (100%) diff --git a/README.md b/README.md index 33af7257..9a3ea0fa 100644 --- a/README.md +++ b/README.md @@ -109,9 +109,9 @@ realm.write([&cars](){ ## Getting Started -See the detailed instructions in our [docs](https://www.mongodb.com/docs/atlas/device-sdks/sdk/cpp/). +See the detailed instructions in our [docs](docs/README.md). -The API reference is located [here](https://www.mongodb.com/docs/realm-sdks/cpp/latest/). +The `cpprealm` API reference docs can be generated locally using Doxygen. ## Installing Realm diff --git a/docs-sdk/cpp.md b/docs/README.md similarity index 100% rename from docs-sdk/cpp.md rename to docs/README.md diff --git a/docs-sdk/crud.md b/docs/guides/crud.md similarity index 100% rename from docs-sdk/crud.md rename to docs/guides/crud.md diff --git a/docs-sdk/crud/create.md b/docs/guides/crud/create.md similarity index 100% rename from docs-sdk/crud/create.md rename to docs/guides/crud/create.md diff --git a/docs-sdk/crud/delete.md b/docs/guides/crud/delete.md similarity index 100% rename from docs-sdk/crud/delete.md rename to docs/guides/crud/delete.md diff --git a/docs-sdk/crud/filter-data.md b/docs/guides/crud/filter-data.md similarity index 100% rename from docs-sdk/crud/filter-data.md rename to docs/guides/crud/filter-data.md diff --git a/docs-sdk/crud/read.md b/docs/guides/crud/read.md similarity index 100% rename from docs-sdk/crud/read.md rename to docs/guides/crud/read.md diff --git a/docs-sdk/crud/threading.md b/docs/guides/crud/threading.md similarity index 100% rename from docs-sdk/crud/threading.md rename to docs/guides/crud/threading.md diff --git a/docs-sdk/crud/update.md b/docs/guides/crud/update.md similarity index 100% rename from docs-sdk/crud/update.md rename to docs/guides/crud/update.md diff --git a/docs-sdk/images/geoboxes-query.png b/docs/guides/images/geoboxes-query.png similarity index 100% rename from docs-sdk/images/geoboxes-query.png rename to docs/guides/images/geoboxes-query.png diff --git a/docs-sdk/images/geoboxes.png b/docs/guides/images/geoboxes.png similarity index 100% rename from docs-sdk/images/geoboxes.png rename to docs/guides/images/geoboxes.png diff --git a/docs-sdk/images/geocircles-query.png b/docs/guides/images/geocircles-query.png similarity index 100% rename from docs-sdk/images/geocircles-query.png rename to docs/guides/images/geocircles-query.png diff --git a/docs-sdk/images/geocircles.png b/docs/guides/images/geocircles.png similarity index 100% rename from docs-sdk/images/geocircles.png rename to docs/guides/images/geocircles.png diff --git a/docs-sdk/images/geopoints.png b/docs/guides/images/geopoints.png similarity index 100% rename from docs-sdk/images/geopoints.png rename to docs/guides/images/geopoints.png diff --git a/docs-sdk/images/geopolygons-query.png b/docs/guides/images/geopolygons-query.png similarity index 100% rename from docs-sdk/images/geopolygons-query.png rename to docs/guides/images/geopolygons-query.png diff --git a/docs-sdk/images/geopolygons.png b/docs/guides/images/geopolygons.png similarity index 100% rename from docs-sdk/images/geopolygons.png rename to docs/guides/images/geopolygons.png diff --git a/docs-sdk/images/mvcc-diagram.png b/docs/guides/images/mvcc-diagram.png similarity index 100% rename from docs-sdk/images/mvcc-diagram.png rename to docs/guides/images/mvcc-diagram.png diff --git a/docs-sdk/install.md b/docs/guides/install.md similarity index 100% rename from docs-sdk/install.md rename to docs/guides/install.md diff --git a/docs-sdk/logging.md b/docs/guides/logging.md similarity index 100% rename from docs-sdk/logging.md rename to docs/guides/logging.md diff --git a/docs-sdk/model-data.md b/docs/guides/model-data.md similarity index 100% rename from docs-sdk/model-data.md rename to docs/guides/model-data.md diff --git a/docs-sdk/model-data/object-models.md b/docs/guides/model-data/object-models.md similarity index 100% rename from docs-sdk/model-data/object-models.md rename to docs/guides/model-data/object-models.md diff --git a/docs-sdk/model-data/relationships.md b/docs/guides/model-data/relationships.md similarity index 100% rename from docs-sdk/model-data/relationships.md rename to docs/guides/model-data/relationships.md diff --git a/docs-sdk/model-data/supported-types.md b/docs/guides/model-data/supported-types.md similarity index 100% rename from docs-sdk/model-data/supported-types.md rename to docs/guides/model-data/supported-types.md diff --git a/docs-sdk/quick-start.md b/docs/guides/quick-start.md similarity index 100% rename from docs-sdk/quick-start.md rename to docs/guides/quick-start.md diff --git a/docs-sdk/react-to-changes.md b/docs/guides/react-to-changes.md similarity index 100% rename from docs-sdk/react-to-changes.md rename to docs/guides/react-to-changes.md diff --git a/docs-sdk/realm-files.md b/docs/guides/realm-files.md similarity index 100% rename from docs-sdk/realm-files.md rename to docs/guides/realm-files.md diff --git a/docs-sdk/realm-files/compact-realm.md b/docs/guides/realm-files/compact-realm.md similarity index 100% rename from docs-sdk/realm-files/compact-realm.md rename to docs/guides/realm-files/compact-realm.md diff --git a/docs-sdk/realm-files/configure-and-open-a-realm.md b/docs/guides/realm-files/configure-and-open-a-realm.md similarity index 100% rename from docs-sdk/realm-files/configure-and-open-a-realm.md rename to docs/guides/realm-files/configure-and-open-a-realm.md diff --git a/docs-sdk/realm-files/encrypt-a-realm.md b/docs/guides/realm-files/encrypt-a-realm.md similarity index 100% rename from docs-sdk/realm-files/encrypt-a-realm.md rename to docs/guides/realm-files/encrypt-a-realm.md From d7e65c247d4791dcec1711da4cb56f9f2eb9c8d5 Mon Sep 17 00:00:00 2001 From: cbullinger <cory.bullinger@mongodb.com> Date: Tue, 23 Sep 2025 11:00:59 -0400 Subject: [PATCH 3/3] Fix ref links and add warning to examples READMEs --- README.md | 1 - docs/README.md | 2 +- examples/Qt/coffee/README.md | 6 ++++++ examples/SPM/README.md | 6 ++++++ examples/cmake/README.md | 6 ++++++ 5 files changed, 19 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 9a3ea0fa..21a7baa5 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,6 @@ This repository holds the source code for the C++ SDK Preview. * **Intuitive to Developers:** Realm’s object-oriented data model is simple to learn, doesn’t need an ORM, and lets you write less code. * **Designed for Offline Use:** Realm’s local database persists data on-disk, so apps work as well offline as they do online. * **Built for Mobile:** Realm is fully-featured, lightweight, and efficiently uses memory, disk space, and battery life. -* **[Device Sync](https://www.mongodb.com/docs/atlas/app-services/sync/)**: Makes it simple to keep data in sync across users, devices, and your backend in real-time. [Get started for free](https://www.mongodb.com/docs/realm/sdk/cpp/sync/) and [create the cloud backend](http://mongodb.com/realm/register?utm_medium=github_atlas_CTA&utm_source=realm_cpp_github). ## Object-Oriented: Streamline Your Code diff --git a/docs/README.md b/docs/README.md index 1cd34eac..57dcdd1d 100644 --- a/docs/README.md +++ b/docs/README.md @@ -7,7 +7,7 @@ These docs provide minimal-explanation code examples of how to work with the C++ Use the SDK's open-source database - Realm - as an object store on the device. -> **TIP:** See the [Quick Start](/docs/quick-start.md) to integrate +> **TIP:** See the [Quick Start](/docs/guides/quick-start.md) to integrate > Realm into your project and get started. > diff --git a/examples/Qt/coffee/README.md b/examples/Qt/coffee/README.md index 6c79764c..4fc00471 100644 --- a/examples/Qt/coffee/README.md +++ b/examples/Qt/coffee/README.md @@ -1,4 +1,10 @@ # Coffee Machine - Operated and powered by Atlas Device Sync +> [!WARNING] +> We announced the deprecation of Atlas Device Sync + Realm SDKs in September 2024. For more information please see: +> - [SDK Deprecation](https://www.mongodb.com/docs/atlas/device-sdks/deprecation) +> - [Device Sync Deprecation](https://www.mongodb.com/docs/atlas/app-services/sync/device-sync-deprecation) +> + The example extends the [Qt provided Coffee Machine](https://doc.qt.io/qt-6/qtdoc-demos-coffee-example.html) with [Atlas Device Sync](https://www.mongodb.com/docs/atlas/app-services/sync/) - essentially turning the coffee machine into a fleet of coffee machines that can be operated and controlled remotely by an operator. diff --git a/examples/SPM/README.md b/examples/SPM/README.md index e82fa0bd..e2a8f1ac 100644 --- a/examples/SPM/README.md +++ b/examples/SPM/README.md @@ -1,3 +1,9 @@ +> [!WARNING] +> We announced the deprecation of Atlas Device Sync + Realm SDKs in September 2024. For more information please see: +> - [SDK Deprecation](https://www.mongodb.com/docs/atlas/device-sdks/deprecation) +> - [Device Sync Deprecation](https://www.mongodb.com/docs/atlas/app-services/sync/device-sync-deprecation) +> + You will first need to create a [Atlas Device Sync App and turn development mode on for it.](https://www.mongodb.com/docs/atlas/app-services/sync/get-started/) Make sure to enable anonymous authentication. Then replace 'YOUR_APP_ID' in main.cpp with the one you just created. diff --git a/examples/cmake/README.md b/examples/cmake/README.md index 4e9f29d0..44ad1e8d 100644 --- a/examples/cmake/README.md +++ b/examples/cmake/README.md @@ -1,3 +1,9 @@ +> [!WARNING] +> We announced the deprecation of Atlas Device Sync + Realm SDKs in September 2024. For more information please see: +> - [SDK Deprecation](https://www.mongodb.com/docs/atlas/device-sdks/deprecation) +> - [Device Sync Deprecation](https://www.mongodb.com/docs/atlas/app-services/sync/device-sync-deprecation) +> + You will first need to create a [Atlas Device Sync App and turn development mode on for it.](https://www.mongodb.com/docs/atlas/app-services/sync/get-started/) Make sure to enable anonymous authentication.

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�$GD1G6$ySG|e+jP45gZQ&3g*x(EV( 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 tVqTS#NlHTSTy2Ekh(V5UrzJ5^|msz5Lcd ztbA@^BH$hjaV;-E!i8}|(>~eB+6^{NX;k$kn<*{}r^B%s&w~|kQSM&T*`rey3A(?oQ1gXT8Cz1@zq!EcB%zGYE#d`bZ3P+g8n?P`B8gV#x zRYi1St-MaY9ux8Xs+ECZB@o$FSeMm-1{u z-lWekpD4^viAx^18bXOFIr(6+rqtoc6ddCvUTvq|v7(3w_X!yc7%UTS%MKghbl$!f76`Z cNdb@WQr4wq>8h{5Frc7hBo!qp#0&!e7eTa8Pyhe` literal 0 HcmV?d00001 diff --git a/docs-sdk/images/geopolygons.png b/docs-sdk/images/geopolygons.png new file mode 100644 index 0000000000000000000000000000000000000000..a40b681251a7ead4cc8f23cbc5fe1e9efeddc86a GIT binary patch literal 56163 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