10.1.3 - Bug fixes

Fixed

• Fixed a compiler bug that would result in an "Access violation" error being thrown when using sync on Windows.

Unity support

The Unity packages are very early previews and are considered unstable. We do not recommend using them in production because issues are expected, especially when compiling with IL2CPP.

10.2.0-beta.1 - Guid, Set, Dictionary, and RealmValue support

This beta release introduces support for 4 new datatypes - Guid, ISet<T>, IDictionary<string, T>, and RealmValue. It also includes multiple bug fixes for our Unity packages, so if you're alpha testing the Unity releases, it is strongly recommended that you upgrade to this version.

Downgrade considerations

Downgrading to an earlier version of the Realm SDK is not supported, so it is strongly recommended that you do not publish production apps using beta versions of the SDK.

Compatibility

This release is incompatible with Stable versions of Realm Studio. A compatible beta version of Realm Studio is coming soon.

Unity

Unity binaries are provided with this release as a very early preview. We don't officially support Unity as a platform yet, so it is expected that there are bugs and missing functionality.

Fixed

• Fixed an issue that would result in UWP apps being rejected from the Microsoft Store due to an unsupported API (__C_specific_handler) being used. (Issue #2235)
• Fixed a bug where applying multiple OrderBy clauses on a query would result in the clauses being appended to each other as if they were .ThenBy rather than the last clause replacing the preceding ones. (PR #2255)
• When explicitly specifying SyncConfiguration.ObjectTypes, added a check to validate the schema and ensure all EmbeddedObject classes are reachable from a class inheriting from RealmObject. More info about this subject can be found here. (PR #2259)

Enhancements

• Add support for the Guid data type. It can be used as primary key and is indexable. (PR #2120)

• Add support for dictionaries. Currently only string keys are supported, while the value
  type may be any of the supported types (the primitive types or custom types that inherit
  from RealmObject/EmbeddedObject). Lists, sets, or other dictionaries may not be used as
  the value type. To add a dictionary to your model, define a getter-only property of type
  IDictionary<string, T>:

  public class MyObject : RealmObject
  {
      public IDictionary<string, decimal> Denominations { get; }
  }
  
  // Realm will automatically manage the underlying dictionary, so there's no need
  // to define a constructor  or assign it to some value.
  
  var obj = new MyObject();
  obj.Denominations.Add("quarter", 0.25d);

• Add support for RealmValue data type. This new type can represent any valid Realm data type, including objects. Collections (lists, sets and dictionaries) of RealmValue are also supported, but 'RealmValue' cannot contain collections. Please note that a property of type RealmValue cannot be nullable, but can contain null, represented by the value RealmValue.Null. (PR #2252)

  public class MyObject : RealmObject
  {
      public RealmValue MyValue { get; set; }
  
      public IList<RealmValue> ValuesList { get; }
  
      public ISet<RealmValue> ValuesSet { get; }
  
      public IDictionary<string, RealmValue> ValuesDict { get; }
  }
  
  var obj = new MyObject();
  obj.MyValue = RealmValue.Null;
  obj.MyValue = 1;
  obj.MyValue = "abc";
  
  if (obj.Type == RealmValueType.String)
  {
      var myString = obj.MyValue.AsString();
  }

• Add support for sets of objects or primitive values. Sets are unordered collections that ensure uniqueness of their elements. Realm uses its internal equality comparer
  and it is not possible to customize its behavior by overriding Equals or GetHashCode on your custom classes. Objects will always be compared by db reference - i.e.
  two distinct objects in the database will always be different, even if their contents are identical, and multiple references to the same database object will always be
  equal.

  public class MyObject : RealmObject
  {
      public ISet<string> UniqueStrings { get; }
  }
  
  // Realm will automatically manage the underlying set, so there's no need
  // to define a constructor  or assign it to some value.
  
  var obj = new MyObject();
  var didAdd = obj.UniqueStrings.Add("foo"); // true
  didAdd = obj.UniqueStrings.Add("foo"); // false

• Added support for value substitution in string based queries. This enables expressions following this syntax: realm.All<T>().Filter("field1 = $0 && field2 = $1", 123, "some-string-value"). (Issue #1822)

• Reduced the size of the native binaries by ~5%. (PR #2239)

• Added a new class - Logger, which allows you to override the default logger implementation (previously writing to stdout or stderr) with a custom one by setting
  Logger.Default. This replaces AppConfiguration.CustomLogger and AppConfiguration.LogLevel which will be removed in a future release. The built-in implementations are:

  • Console - uses the System.Console for most projects and UnityEngine.Debug for Unity projects: Logger.Default = Logger.Console;
  • Null - ignores all messages: Logger.Default = Logger.Null;
  • Function - proxies calls to a supplied function: Logger.Default = Logger.Function(message => myExternalLogger.Log(message));

  Custom loggers can derive from the Logger class and provide their own implementation for the Log method or use Function and provide an Action<string>. (PR #2276)

• RealmObjectBase now correctly overrides and implements GetHashCode(). (Issue #1650)

Unity support

The Unity packages are very early previews and are considered unstable. We do not recommend using them in production because issues are expected, especially when compiling with IL2CPP.

10.1.2 - Bug fixes

Fixed

• On 32bit devices you may get exception with "No such object" when upgrading to v10. (Core upgrade)
• The notification worker thread would rerun queries after every commit rather than only commits which modified tables which could affect the query results if the table had any outgoing links to tables not used in the query. (Core upgrade)
• Fix "Invalid ref translation entry [16045690984833335023, 78187493520]" assertion failure which could occur when using sync or multiple processes writing to a single Realm file. (Core upgrade)
• During integration of a large amount of data from the server, you may get "Assertion failed: !fields.has_missing_parent_update()". (Core upgrade)
• Syncing large Decimal128 values will cause "Assertion failed: cx.w[1] == 0". (Core upgrade)
• Avoid race condition leading to possible hangs on windows. (Core upgrade)

Unity support

The Unity packages are very early previews and are considered unstable. We do not recommend using them in production because issues are expected, especially when compiling with IL2CPP.

10.1.1 - Bug fixes

Fixed

• Fixed an issue that would result in UWP apps being rejected from the Microsoft Store due to an unsupported API (__C_specific_handler) being used. (Issue #2235)
• The Realm notification listener thread could sometimes hit the assertion failure "!skip_version.version" if a write transaction was committed at a very specific time. (Core upgrade)

Unity support

The Unity packages are very early previews and are considered unstable. We do not recommend using them in production because issues are expected, especially when compiling with IL2CPP.

5.1.3 - Bug fixes

Fixed

• If you make a case insensitive query on an indexed string column, it may fail in a way that results in a "No such key" exception. (Core upgrade)
• Fix crash in case insensitive query on indexed string columns when nothing matches. (Core upgrade)
• Files upgraded on 32-bit devices could end up being inconsistent resulting in "Key not found" exception to be thown. (Core upgrade)
• Fixed an issue where creating an object after file format upgrade may fail with assertion Assertion failed: lo() <= std::numeric_limits<uint32_t>::max(). (Core upgrade)

Compatibility

• Realm Object Server: 3.23.1 or later.

10.1.0 - Bug fixes

Enhancements

• Sync client now logs error messages received from server rather than just the size of the error message. (Core upgrade)
• Errors returned from the server when sync WebSockets get closed are now captured and surfaced as a SyncError. (Core upgrade)
• Dramatically improved performance of sequential reads on a query without a filter. (Core upgrade)

Fixed

• Fix an issue when using a frozen query across threads with different transaction versions which resulted in being able to access objects from a future version in the frozen collection. (Core upgrade)
• Fixed an issue where creating an object after file format upgrade may fail with assertion "Assertion failed: lo() <= std::numeric_limits<uint32_t>::max()" (Core upgrade)
• Fixed an issue where getting an element from a query result without a filter would give incorrect results if a new object was created at index zero in the source Table. (Core upgrade)
• Fixed an issue where during synchronization the app would crash with Assertion failed: ref + size <= next->first. (Core upgrade)

Compatibility

• Realm Studio: 10.0.0 or later.

10.0.1 - Decimal, ObjectId, Embedded Objects + MongoDB Realm support

This is the first stable release from the v10 line of releases - the changelog includes all changes introduced between 10.0.0-beta.1 through beta.6. It adds multiple improvements to the local database as well as support for synchronizing with MongoDB Realm Cloud (https://realm.mongodb.com). It no longer supports legacy Realm Cloud (https://cloud.realm.io), so users who haven't migrated to MongoDB Realm should not upgrade.

Breaking Changes

• We no longer support Realm Cloud (legacy), but instead the new MongoDB Realm Cloud. MongoDB Realm is a serverless platform that enables developers to quickly build applications without having to set up server infrastructure. MongoDB Realm is built on top of MongoDB Atlas, automatically integrating the connection to your database. (#2011)
• Remove support for Query-based sync, including the configuration parameters and the SyncSubscription types. (#2011)
• Remove everything related to sync permissions, including both the path-based permission system and the object-level privileges for query-based sync. Permissions in MongoDB Realm are defined serverside. (#2011)
• Moved all API for dynamic access on the Realm class to Realm.DynamicApi:
  • Realm.CreateObject(string className, object primaryKey) is now Realm.DynamicApi.CreateObject(string className, object primaryKey).
  • Realm.All(string className) is now Realm.DynamicApi.All(string className).
  • Realm.RemoveAll(string className) is now Realm.DynamicApi.RemoveAll(string className).
  • Realm.Find(string className, long? primaryKey) is now Realm.DynamicApi.Find(string className, long? primaryKey).
  • Realm.Find(string className, string primaryKey) is now Realm.DynamicApi.Find(string className, string primaryKey).
• It is now required that all top-level objects in a synchronized Realm have a primary key called _id. You can use the MapTo("_id") attribute to avoid using unidiomatic names for the model properties.
• Bumped the minimum target for Xamarin.iOS apps to iOS 9.
• Bumped the minimum API level for Xamarin.Android apps to 16 (Android 4.1).
• Renamed FullSyncConfiguration to SyncConfiguration.
• Removed RealmObject.FreezeInPlace. To freeze a realm object use the Freeze extension method. (Issue #2180)

Enhancements

• Added support for syncing to MongoDB instead of Realm Object Server. Applications must be created at realm.mongodb.com.

• Added an App class which is the entrypoint for synchronizing with a MongoDB Realm App.

• Added User.CustomData containing an unstructured document with additional information about the user. Custom data is configured in your MongoDB Realm App.

• Added User.Functions. This is the entry point for calling Remote MongoDB Realm functions. Functions allow you to define and execute server-side logic for your application. Functions are written in modern JavaScript (ES6+) and execute in a serverless manner. When you call a function, you can dynamically access components of the current application as well as information about the request to execute the function and the logged in user that sent the request.

• Added User.GetMongoClient exposing an API for CRUD operations on a Remote MongoDB Service.

• Added User.GetPushClient exposing an API for registering a device for push notifications.

• Change SyncConfiguration to accept partition value instead of a server Uri. Partition values can currently be of types string, long, or ObjectId. Opening a realm by partition value is the equivalent of previously opening a realm by URL. In this case, partitions are meant to be more closely associated with your data. E.g., if you are a large retailer with multiple locations, the partition key can be the store Id and you each Realm will only contain data related to the specified store.

• Add support for the Decimal128 data type. This is a 128-bit IEEE 754 decimal floating point number. Properties of this type can be declared either as MongoDB.Bson.Decimal128 type or the built-in decimal type. Note that .NET's built-in decimal is 96-bit, so it cannot represent the full range of numbers, representable by Decimal128. (PR #2014)

• Add support for the ObjectId data type. This is a 12 byte unique identifier that is common as a document id in MongoDB databases. It can be used as primary key. (PR #2035)

• Add support for embedded objects. Embedded objects are objects which are owned by a single parent object, and are deleted when that parent object is deleted or their parent no longer references them. Embedded objects are declared by subclassing EmbeddedObject instead of RealmObject. Reassigning an embedded object is not allowed and neither is linking to it from multiple parents. Querying for embedded objects directly is also disallowed as they should be viewed as complex structures belonging to their parents as opposed to standalone objects. A trivial example is:

  public class Address : EmbeddedObject
  {
      public string Street { get; set; }
  
      public string City { get; set; }
  }
  
  public class Person : RealmObject
  {
      public string Name { get; set; }
  
      // Address is an embedded object - you reference it as usual
      public Address Address { get; set; }
  }
  
  public class Company : RealmObject
  {
      public string PhoneNumber { get; set; }
  
      // Embedded objects can be contained in lists too
      public IList<Address> OfficeAddresses { get; }
  }

• Added new dynamic methods for instantiating embedded objects:

  • Realm.DynamicApi.CreateEmbeddedObjectForProperty should be used to create an embedded object and assign it to a parent's property. For example:

    // static API
    var person = new Person();
    person.Address = new Address
    {
        City = "New York"
    };
    
    // dynamic API
    var dynamicPerson = realm.DynamicApi.CreateObject("Person");
    var address = realm.DynamicApi.CreateEmbeddedObjectForProperty(dynamicPerson, "Address")
    address.City = "New York";

  • Realm.DynamicApi.AddEmbeddedObjectToList should be used to create an embedded object and add it to a parent's list property.

  • Realm.DynamicApi.InsertEmbeddedObjectInList should be used to create an embedded object and insert it in a parent's list property at a specified index.

  • Realm.DynamicApi.SetEmbeddedObjectInList should be used to create an embedded object and set it at an index in a parent's list property.

    // static API
    var company = new Company();
    company.OfficeAddresses.Add(new Address
    {
        City = "New York"
    });
    
    company.OfficeAddresses.Insert(0, new Address
    {
        City = "Palo Alto"
    });
    
    company.OfficeAddresses[1] = new Address
    {
        City = "New Jersey"
    };
    
    // dynamic API
    var dynamicCompany = realm.DynamicApi.CreateObject("Company");
    var officeToAdd = realm.DynamicApi.AddEmbeddedObjectToList(dynamicCompany.OfficeAddresses);
    officeToAdd.City = "New York";
    
    var officeToInsert = realm.DynamicApi.InsertEmbeddedObjectInList(dynamicCompany.OfficeAddresses, 0);
    officeToInsert.City = "Palo Alto";
    
    var officeToSet = realm.DynamicApi.SetEmbeddedObjectInList(dynamicCompany.OfficeAddresses, 1);
    officeToSet.City = "New Jersey";

• The memory mapping scheme for Realm files has changed to better support opening very large files.

• Replaced the implementation of the string query parser (the one used for realm.All().Filter("some-string-query")). This results in ~5% reduction of the size of the native binary while keeping the query execution times on par with the old parser. (PR #2185, Core upgrade)

• Optimized the internal code that handles conversions between types. This should result in a minor performance increase
  for most data operations that should be most noticeable on Ahead-of-Time compiled platforms, such as iOS/UWP. Due to the
  nature of the change, it's possible that conversions that previously happened automatically when working with dynamic objects
  no longer do. If you encounter a NotSupportedException with the message No conversion exists from *type A* to *type B*
  and believe this is a bug, please open a Github Issue. (PR #2149)

• Added an extra compile-time check to detect erroneous List declarations and suggest IList for collection properties in Realm objects. (Issue #2083)

• Added overloads for Realm.Write and Realm.WriteAsync that can return a value. (Issue #2081)

Fixed

• Worked around an issue with the .NET Native compiler (used in UWP projects) that would result in the following exception being thrown in Release: Incompatible MarshalAs detected in parameter named 'value'. Please refer to MCG's warning message for more information.. (Issue #2169)
• Fixed a bug that could cause incorrect property values to be read during a migration for apps running on .NET Core 3.0 or newer.
  The issue manifests itself when different classes have persisted properties with the same name and...

10.0.0-beta.6 - Fix for date regression from beta.5

Fixed

• Fixed a regression in 10.0.0-beta.5 that incorrectly stores and retrieves DateTimeOffset values. (PR #2200)

Compatibility

• Realm Studio: 10.0.0 or later.

[Don't use!] 10.0.0-beta.5 - Sync SSL fix + Windows multiprocess support

Don't use this version

This version has a serious regression related to reading and writing date properties. It stores dates in an incorrect format at the database layer, which means that values written in earlier versions will be read incorrectly (typically values very close to 0000-01-01) and values written with this version will be read incorrectly with future versions.

Description

This is primarily a bug fix release that addresses an SSL regression in beta.3 and fixes a long standing bug with multiprocess support on Windows. There is no public beta.4 release, so beta.5 follows immediately after beta.3.

Breaking Changes

• Removed RealmObject.FreezeInPlace. To freeze a realm object use the Freeze extension method. (Issue #2180)

Fixed

• Worked around an issue with the .NET Native compiler (used in UWP projects) that would result in the following exception being thrown in Release: Incompatible MarshalAs detected in parameter named 'value'. Please refer to MCG's warning message for more information.. (Issue #2169)
• Fixed a bug that could cause a deadlock in a multiprocess scenario where multiple processes share the same Realm file and listen for notifications from the file. (Core upgrade)
• Fixed an issue where Sync connections would fail on Windows due to SSL server certificate rejected. (Core upgrade)
• Fixed an issue with deleting and recreating objects with embedded objects. (Core upgrade)
• Fix a race condition which would lead to "uncaught exception in notifier thread: N5realm15InvalidTableRefE: transaction_ended" and a crash when the source Realm was closed or invalidated at a very specific time during the first run of a collection notifier (Core upgrade)

Enhancements

• Replaced the implementation of the string query parser (the one used for realm.All().Filter("some-string-query")). This results in ~5% reduction of the size of the native binary while keeping the query execution times on par with the old parser. (PR #2185, Core upgrade)

Unity

Starting with beta.5, we're publishing very early prerelease bundles of a Unity-compatible package. These are in no way supported and we strongly advise against using them in production. That being said, we will respond to and address issues and plan to ship fully-fledged and supported Unity package at a later point.

To install the Unity package, open the Unity Package Manager and select the Add package from tarball option. The two packages we publish are:

• realm.unity-*version*.tgz: this package contains the Realm precompiled .dll as well as all the native binaries for all platforms. It doesn't include any of the managed dependencies, such as MongoDB.Bson or Remotion.Linq. It's up to the developer to satisfy those dependencies with versions equal to or newer than the versions listed on NuGet (Note that Fody and Realm.Fody are not dependencies of the Unity package and don't need to be installed).
• realm.unity.bundle-*version*.tgz: this package contains everything in the first one + all the managed dependencies at their correct versions. This is the easiest package to get started with, but may introduce conflicts in case your project already bundles a dependency that Realm brings in, such as System.Buffers or MongoDB.Bson.

10.0.0-beta.3 - Bug fixes

Breaking Changes

• Credentials.Google(string) now has an additional argument of type GoogleCredentialType. The available types are IdToken and AuthCode and specify what type of credential the passed string represents.

Fixed

• Fixed a bug that could cause incorrect property values to be read during a migration for apps running on .NET Core 3.0 or newer. The issue manifests itself when different classes have persisted properties with the same name and could result in the wrong property being accessed - e.g. foo.Name could return foo.Bar. This could only happen when using the dynamic API during a migration and does not affect apps that use the strongly typed API or run on platforms other than .NET Core 3.x/.NET 5.
• Fixed an issue that would cause deadlocks on Windows systems when 3 or more processes were listening for notifications on the same Realm file. (Core upgrade)
• Fixed a bug that would prevent eventual consistency during conflict resolution. Affected clients would experience data divergence and potentially consistency errors as a result if they experienced conflict resolution between cycles of Create-Erase-Create for objects with the same primary key. (Core upgrade)
• Fixed a bug that could lead to a crash when refreshing the user's custom data. (Core upgrade)
• Fixed a bug that could cause an assertion n != realm::npos when integrating changesets from the server. (Core upgrade)

Enhancements

• Added support of OpenID Connect credential for the Google authentication provider. (Issue #2108)
• Optimized the internal code that handles conversions between types. This should result in a minor performance increase for most data operations that should be most noticeable on Ahead-of-Time compiled platforms, such as iOS/UWP. Due to the nature of the change, it's possible that conversions that previously happened automatically when working with dynamic objects no longer do. If you encounter a NotSupportedException with the message No conversion exists from *type A* to *type B* and believe this is a bug, please open a Github Issue. (PR #2149)

Compatibility

• Realm Studio: 10.0.0 or later.