RNET-1145, RNET-1143: Fix reading schema from native

CHANGELOG.md

@@ -1,10 +1,10 @@
 ## vNext (TBD)
 
 ### Enhancements
-* None
+* Added support for `Migration.FindInNewRealm` which is a helper that allows you to lookup the object in the post-migration Realm that corresponds to an object from the pre-migration Realm. (Issue [#3600](https://github.com/realm/realm-dotnet/issues/3600))
 
 ### Fixed
-* None
+* Fixed an issue that would cause `RealmObject.DynamicApi.GetList/Set/Dictionary` to fail when the collection contains primitive values. (Issue [#3597](https://github.com/realm/realm-dotnet/issues/3597))
 
 ### Compatibility
 * Realm Studio: 15.0.0 or later.

Realm/Realm/Handles/SharedRealmHandle.cs

@@ -229,6 +229,9 @@ public static extern void rename_property(SharedRealmHandle sharedRealm,
             [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_get_operating_system", CallingConvention = CallingConvention.Cdecl)]
             public static extern IntPtr get_operating_system(IntPtr buffer, IntPtr buffer_length);
 
+            [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_get_object_for_object", CallingConvention = CallingConvention.Cdecl)]
+            public static extern IntPtr get_object_for_object(SharedRealmHandle realmHandle, ObjectHandle handle, out NativeException ex);
+
 #pragma warning restore SA1121 // Use built-in type alias
 #pragma warning restore IDE0049 // Use built-in type alias
         }
@@ -677,6 +680,21 @@ public bool TryFindObject(TableKey tableKey, in RealmValue id, [MaybeNullWhen(fa
             return true;
         }
 
+        public bool TryFindObject(ObjectHandle handle, [MaybeNullWhen(false)] out ObjectHandle objectHandle)
+        {
+            var result = NativeMethods.get_object_for_object(this, handle, out var ex);
+            ex.ThrowIfNecessary();
+
+            if (result == IntPtr.Zero)
+            {
+                objectHandle = null;
+                return false;
+            }
+
+            objectHandle = new ObjectHandle(this, result);
+            return true;
+        }
+
         public void RenameProperty(string typeName, string oldName, string newName, IntPtr migrationSchema)
         {
             NativeMethods.rename_property(this, typeName, (IntPtr)typeName.Length,

Realm/Realm/Migration.cs

@@ -115,5 +115,27 @@ public void RenameProperty(string typeName, string oldPropertyName, string newPr
 
             NewRealm.SharedRealmHandle.RenameProperty(typeName, oldPropertyName, newPropertyName, _migrationSchema);
         }
+
+        /// <summary>
+        /// Finds an object obtained from <see cref="OldRealm"/> in <see cref="NewRealm"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the object in the new realm.</typeparam>
+        /// <param name="obj">The object obtained from the old realm.</param>
+        /// <returns>The corresponding object post-migration or <c>null</c> if the object no longer exists in the new realm.</returns>
+        /// <example>
+        /// <code>
+        /// foreach (var oldPerson in migration.OldRealm.DynamicApi.All("Person"))
+        /// {
+        ///     var newPerson = migration.FindInNewRealm&lt;Person&gt;(oldPerson)
+        ///     newPerson.Name = $"{oldPerson.DynamicApi.Get&lt;string&gt;("FirstName")} {oldPerson.DynamicApi.Get&lt;string&gt;("LastName")}";
+        /// }
+        /// </code>
+        /// </example>
+        public T? FindInNewRealm<T>(IRealmObject obj)
+            where T : IRealmObject
+        {
+            Argument.Ensure(obj.IsManaged, "Only managed RealmObject instances can be looked up in the new Realm", nameof(obj));
+            return NewRealm.FindExisting<T>(obj);
+        }
     }
 }

Realm/Realm/Native/PrimitiveValue.cs

@@ -353,7 +353,12 @@ public static StringValue AllocateFrom(string? value, Arena arena)
 
         public static implicit operator bool(in StringValue value) => value.data != null;
 
-        public static implicit operator string?(in StringValue value) => !value ? null : Encoding.UTF8.GetString(value.data, (int)value.size);
+        public static implicit operator string?(in StringValue value) => value.ToDotnetString();
+
+        public readonly string? ToDotnetString(bool treatEmptyAsNull = false)
+            => data == null || (size == 0 && treatEmptyAsNull)
+            ? null
+            : Encoding.UTF8.GetString(data, (int)size);
     }
 
     [StructLayout(LayoutKind.Sequential)]

Realm/Realm/Realm.cs

@@ -1111,6 +1111,21 @@ internal IQueryable<T> AllEmbedded<T>()
             return default;
         }
 
+        // This is only used during migrations. obj here is the object in the old realm, and we're trying to find
+        // its counterpart post-migration.
+        internal T? FindExisting<T>(IRealmObject obj)
+        {
+            ThrowIfDisposed();
+            Argument.Ensure(obj.IsManaged, "Only managed objects can be used in FindExisting", nameof(obj));
+            if (SharedRealmHandle.TryFindObject(obj.GetObjectHandle()!, out var objectHandle))
+            {
+                var metadata = Metadata[typeof(T).GetMappedOrOriginalName()];
+                return (T)MakeObject(metadata, objectHandle);
+            }
+
+            return default;
+        }
+
         #endregion Quick Find using primary key
 
         #region Thread Handover
@@ -1589,7 +1604,7 @@ internal Dynamic(Realm realm)
             public IRealmObjectBase CreateObject(string className) => CreateObjectCore(className, primaryKey: null);
 
             /// <summary>
-            /// Factory for a managed object without a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
+            /// Factory for a managed object with a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
             /// </summary>
             /// <returns>A dynamically-accessed Realm object.</returns>
             /// <param name="className">The type of object to create as defined in the schema.</param>
@@ -1609,7 +1624,7 @@ internal Dynamic(Realm realm)
             public IRealmObjectBase CreateObject(string className, long? primaryKey) => CreateObjectCore(className, primaryKey);
 
             /// <summary>
-            /// Factory for a managed object without a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
+            /// Factory for a managed object with a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
             /// </summary>
             /// <returns>A dynamically-accessed Realm object.</returns>
             /// <param name="className">The type of object to create as defined in the schema.</param>
@@ -1629,7 +1644,7 @@ internal Dynamic(Realm realm)
             public IRealmObjectBase CreateObject(string className, string? primaryKey) => CreateObjectCore(className, primaryKey);
 
             /// <summary>
-            /// Factory for a managed object without a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
+            /// Factory for a managed object with a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
             /// </summary>
             /// <returns>A dynamically-accessed Realm object.</returns>
             /// <param name="className">The type of object to create as defined in the schema.</param>
@@ -1649,7 +1664,7 @@ internal Dynamic(Realm realm)
             public IRealmObjectBase CreateObject(string className, ObjectId? primaryKey) => CreateObjectCore(className, primaryKey);
 
             /// <summary>
-            /// Factory for a managed object without a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
+            /// Factory for a managed object with a primary key in a realm. Only valid within a write <see cref="Transaction"/>.
             /// </summary>
             /// <returns>A dynamically-accessed Realm object.</returns>
             /// <param name="className">The type of object to create as defined in the schema.</param>

Realm/Realm/Schema/Property.cs

@@ -170,11 +170,10 @@ public Property(string name, PropertyType type, string? objectType = null, strin
         internal Property(in SchemaProperty nativeProperty)
         {
             Name = nativeProperty.name!;
-            string? managedName = nativeProperty.managed_name;
-            ManagedName = !string.IsNullOrEmpty(managedName) ? managedName! : Name;
+            ManagedName = nativeProperty.managed_name.ToDotnetString(treatEmptyAsNull: true) ?? Name;
             Type = nativeProperty.type;
-            ObjectType = nativeProperty.object_type;
-            LinkOriginPropertyName = nativeProperty.link_origin_property_name;
+            ObjectType = nativeProperty.object_type.ToDotnetString(treatEmptyAsNull: true);
+            LinkOriginPropertyName = nativeProperty.link_origin_property_name.ToDotnetString(treatEmptyAsNull: true);
             IsPrimaryKey = nativeProperty.is_primary;
             IndexType = nativeProperty.index;
         }

Tests/Realm.Tests/Database/MigrationTests.cs

@@ -834,6 +834,113 @@
             Assert.That(newRealm.AllEmbedded<ObjectEmbedded>().Count(), Is.EqualTo(1));
             Assert.That(newRealm.AllEmbedded<ObjectEmbedded>().Any(e => e.Value == "bar"), Is.False);
         }
+
+        [Test]
+        public void Migration_FindInNewRealm_WhenObjectIsDeleted_ReturnsNull()
+        {
+            var oldConfig = new RealmConfiguration(Guid.NewGuid().ToString())
+            {
+                Schema = new[]
+                {
+                    typeof(Dotnet_3597_Old)
+                }
+            };
+
+            using (var oldRealm = GetRealm(oldConfig))
+            {
+                oldRealm.Write(() =>
+                {
+                    oldRealm.Add(new Dotnet_3597_Old { FloatProp = 1, IntProp = 1 });
+                    oldRealm.Add(new Dotnet_3597_Old { FloatProp = 2, IntProp = 2 });
+                });
+            }
+
+            var newConfig = new RealmConfiguration(oldConfig.DatabasePath)
+            {
+                Schema = new[]
+                {
+                    typeof(Dotnet_3597)
+                },
+                SchemaVersion = 2,
+                MigrationCallback = (migration, version) =>
+                {
+                    var oldObjects = migration.OldRealm.DynamicApi.All(nameof(Dotnet_3597)).ToArray();
+                    var old1 = oldObjects.First(o => o.DynamicApi.Get<int>("IntProp") == 1);
+                    var old2 = oldObjects.First(o => o.DynamicApi.Get<int>("IntProp") == 2);
+
+                    var newObjects = migration.NewRealm.All<Dotnet_3597>().ToArray();
+                    var new1 = newObjects.First(o => o.IntProp == 1);
+                    var new2 = newObjects.First(o => o.IntProp == 2);
+
+                    Assert.That(migration.FindInNewRealm<Dotnet_3597>(old1), Is.EqualTo(new1));
+                    Assert.That(migration.FindInNewRealm<Dotnet_3597>(old2), Is.EqualTo(new2));
+
+                    migration.NewRealm.Remove(new1);
+
+                    Assert.That(migration.FindInNewRealm<Dotnet_3597>(old1), Is.Null);
+                }
+            };
+
+            var newRealm = GetRealm(newConfig);
+            Assert.That(newRealm.All<Dotnet_3597>().Count(), Is.EqualTo(1));
+        }
+
+        // Test for https://github.com/realm/realm-dotnet/issues/3597
+        [Test]
+        public void Migration_MigratesListOfFloats()
+        {
+            var oldConfig = new RealmConfiguration(Guid.NewGuid().ToString())
+            {
+                Schema = new[]
+                {
+                    typeof(Dotnet_3597_Old)
+                }
+            };
+
+            using (var oldRealm = GetRealm(oldConfig))
+            {
+                oldRealm.Write(() =>
+                {
+                    oldRealm.Add(new Dotnet_3597_Old
+                    {
+                        FloatProp = 3.14f,
+                        FloatList =
+                        {
+                            1,
+                            2,
+                            -1.23f
+                        }
+                    });
+                });
+            }
+
+            var newConfig = new RealmConfiguration(oldConfig.DatabasePath)
+            {
+                Schema = new[]
+                {
+                    typeof(Dotnet_3597)
+                },
+                SchemaVersion = 2,
+                MigrationCallback = (migration, version) =>
+                {
+                    foreach (var item in migration.OldRealm.DynamicApi.All(nameof(Dotnet_3597)))
+                    {
+                        var newItem = migration.FindInNewRealm<Dotnet_3597>(item)!;
+                        newItem.FloatProp = item.DynamicApi.Get<float?>("FloatProp").ToString()!;
+                        foreach (var floatValue in item.DynamicApi.GetList<float?>("FloatList"))
+                        {
+                            newItem.FloatList.Add(floatValue.ToString()!);
+                        }
+                    }
+                }
+            };
+
+            var newRealm = GetRealm(newConfig);
+
+            var obj = newRealm.All<Dotnet_3597>().Single();
+            Assert.That(obj.FloatProp, Is.EqualTo("3.14"));
+            CollectionAssert.AreEqual(obj.FloatList, new[] { "1", "2", "-1.23" });
+        }
     }
 
     [Explicit]
@@ -884,4 +991,26 @@
     {
         public string? Value { get; set; }
     }
+
+    [Explicit]
+    [MapTo("Dotnet_3597")]
+    public partial class Dotnet_3597_Old : TestRealmObject
+    {
+        public int IntProp { get; set; }
+
+        public float? FloatProp { get; set; }
+
+        public IList<float?> FloatList { get; }
+    }
+
+    [Explicit]
+    [MapTo("Dotnet_3597")]
+    public partial class Dotnet_3597 : TestRealmObject
+    {
+        public int IntProp { get; set; }
+
+        public string FloatProp { get; set; }
+
+        public IList<string> FloatList { get; }
+    }
 }