Upgrade to core 14 (#8496)

Author: tgoyne

CHANGELOG.md

@@ -1,3 +1,66 @@
+x.y.z Release notes (yyyy-MM-dd)
+=============================================================
+
+This version introduces a new Realm file format version (v24). Opening existing
+Realm files will automatically upgrade the files, making them unable to be
+opened by older versions. This upgrade process should typically be very fast
+unless you have large Sets of AnyRealmValue, String, or Data, which have to be rewritten.
+
+A backup will automatically be created next to the Realm before performing the
+upgrade. Downgrading to older versions of Realm will attempt to automatically
+restore the backup, or it will be deleted after three months.
+
+### Enhancements
+* Storage of Decimal128 properties has been optimised similarly to Int
+  properties so that the individual values will take up 0 bits (if all nulls),
+  32 bits, 64 bits or 128 bits depending on what is needed.
+  ([Core #6111](https://github.com/realm/realm-core/pull/6111))
+* Improve file compaction performance on arm64 platforms for encrypted files
+  between 16kB and 4MB in size. ([PR #7492](https://github.com/realm/realm-core/pull/7492)).
+
+### Fixed
+* Sorting on binary Data was done by comparing bytes as signed char rather than
+  unsigned char, resulting in very strange orders (since sorting on Data was
+  enabled in v6.0.4)
+* Sorting on AnyRealmValue did not use a valid total ordering, and certain
+  combinations of values could result in values not being sorted or potentially
+  even crashes. The resolution for this will result in some previously-valid
+  combinations of values of different types being sorted in different orders
+  than previously (since the introduction of AnyRealmValue in 10.8.0).
+* RLMSet/MutableSet was inconsistent about if it considered a String and a Data
+  containing the utf-8 encoded bytes of that String to be equivalent. They are
+  now always considered distinct. (since the introduction of sets in v10.8.0).
+* Equality queries on a Mixed property with an index could sometimes return
+  incorrect results if values of different types happened to have the same hash
+  code. ([Core 6407](https://github.com/realm/realm-core/issues/6407) since v10.8.0).
+* Creating more than 8388606 links pointing to a single object would crash.
+  ([Core #6577](https://github.com/realm/realm-core/issues/6577), since v5.0.0)
+* A Realm generated on a non-apple ARM 64 device and copied to another platform
+  (and vice-versa) were non-portable due to a sorting order difference. This
+  impacts strings or binaries that have their first difference at a non-ascii
+  character. These items may not be found in a set, or in an indexed column if
+  the strings had a long common prefix (> 200 characters).
+  ([Core #6670](https://github.com/realm/realm-core/pull/6670), since 2.0.0 for indexes, and since since the introduction of sets in v10.8.0)
+* Fix a spurious crash related to opening a Realm on background thread while
+  the process was in the middle of exiting ([Core #7420](https://github.com/realm/realm-core/pull/7420)).
+* Opening a Realm with a cached user while offline would fail to retry some
+  steps of the connection process and instead report a fatal error.
+  ([#7349](https://github.com/realm/realm-core/issues/7349), since v10.46.0)
+
+### Breaking Changes
+* Drop support for opening pre-v5.0.0 Realm files.
+
+### Compatibility
+* Realm Studio: 14.0.1 or later.
+* APIs are backwards compatible with all previous releases in the 10.x.y series.
+* Carthage release for Swift is built with Xcode 15.3.0.
+* CocoaPods: 1.10 or later.
+* Xcode: 14.2-15.3.0. Note that we will be dropping support for Xcode 14 when
+  Apple begins requiring Xcode 15 for app store submissions on April 29.
+
+### Internal
+* Upgraded realm-core from 13.26.0 to 14.3.0
+
 10.48.1 Release notes (2024-03-15)
 =============================================================
 

Package.swift

@@ -3,7 +3,7 @@
 import PackageDescription
 import Foundation
 
-let coreVersion = Version("13.26.0")
+let coreVersion = Version("14.3.0")
 let cocoaVersion = Version("10.48.1")
 
 let cxxSettings: [CXXSetting] = [

Realm/ObjectServerTests/RLMSyncTestCase.mm

@@ -705,7 +705,7 @@ - (RLMMongoCollection *)collectionForType:(Class)type app:(RLMApp *)app {
 @end
 
 int64_t RLMGetClientFileIdent(RLMRealm *realm) {
-    return realm::SyncSession::OnlyForTesting::get_file_ident(*realm->_realm->sync_session()).ident;
+    return realm->_realm->sync_session()->get_file_ident().ident;
 }
 
 #endif // TARGET_OS_OSX

Realm/RLMBSON_Private.hpp

@@ -21,8 +21,7 @@
 
 namespace realm::bson {
 class Bson;
-template <typename> class IndexedMap;
-using BsonDocument = IndexedMap<Bson>;
+class BsonDocument;
 }
 
 realm::bson::Bson RLMConvertRLMBSONToBson(id<RLMBSON> b);

Realm/RLMLogger.mm

@@ -75,15 +75,15 @@ static RLMLogLevel logLevelForLevel(Level logLevel) {
 }
 
 struct CocoaLogger : public Logger {
-    void do_log(Level level, const std::string& message) override {
+    void do_log(const realm::util::LogCategory&, Level level, const std::string& message) override {
         NSLog(@"%@: %@", levelPrefix(level), RLMStringDataToNSString(message));
     }
 };
 
 class CustomLogger : public Logger {
 public:
     RLMLoggerFunction function;
-    void do_log(Level level, const std::string& message) override {
+    void do_log(const realm::util::LogCategory&, Level level, const std::string& message) override {
         @autoreleasepool {
             if (function) {
                 function(logLevelForLevel(level), RLMStringDataToNSString(message));

Realm/RLMMongoCollection.mm

@@ -188,7 +188,7 @@ - (void)insertOneDocument:(NSDictionary<NSString *, id<RLMBSON>> *)document
 - (void)insertManyDocuments:(NSArray<NSDictionary<NSString *, id<RLMBSON>> *> *)documents
                  completion:(RLMMongoInsertManyBlock)completion {
     self.collection.insert_many(toBsonArray(documents),
-                                [completion](std::vector<realm::bson::Bson> insertedIds,
+                                [completion](realm::bson::BsonArray insertedIds,
                                              std::optional<realm::app::AppError> error) {
         if (error) {
             return completion(nil, makeError(*error));

Realm/RLMObservation.mm

@@ -374,7 +374,7 @@ void RLMClearTable(RLMClassInfo &objectSchema) {
             }
 
             NSString *name = observer->columnName(link.origin_col_key);
-            if (observer->getRow().get_table()->get_column_type(link.origin_col_key) != type_LinkList) {
+            if (!link.origin_col_key.is_list()) {
                 _changes.push_back({observer, name});
                 continue;
             }

Realm/RLMQueryUtil.mm

@@ -684,32 +684,30 @@ Query make_diacritic_insensitive_constraint(NSPredicateOperatorType operatorType
     }
 }
 
+// static_assert is always evaluated even if it's inside a if constexpr
+// unless the value is derived from the template argument, in which case it's
+// only evaluated if that branch is active
+template <typename> struct AlwaysFalse : std::false_type {};
+
 template <typename C, typename T>
-void QueryBuilder::do_add_diacritic_sensitive_string_constraint(NSPredicateOperatorType operatorType,
-                                                                NSComparisonPredicateOptions predicateOptions,
-                                                                C&& column, T&& value) {
-    bool caseSensitive = !(predicateOptions & NSCaseInsensitivePredicateOption);
+Query make_diacritic_sensitive_constraint(NSPredicateOperatorType operatorType,
+                                          bool caseSensitive, C& column, T const& value)
+{
     switch (operatorType) {
         case NSBeginsWithPredicateOperatorType:
-            add_substring_constraint(value, column.begins_with(value, caseSensitive));
-            break;
+            return column.begins_with(value, caseSensitive);
         case NSEndsWithPredicateOperatorType:
-            add_substring_constraint(value, column.ends_with(value, caseSensitive));
-            break;
+            return column.ends_with(value, caseSensitive);
         case NSContainsPredicateOperatorType:
-            add_substring_constraint(value, column.contains(value, caseSensitive));
-            break;
+            return column.contains(value, caseSensitive);
         case NSEqualToPredicateOperatorType:
-            m_query.and_query(column.equal(value, caseSensitive));
-            break;
+            return column.equal(value, caseSensitive);
         case NSNotEqualToPredicateOperatorType:
-            m_query.and_query(column.not_equal(value, caseSensitive));
-            break;
+            return column.not_equal(value, caseSensitive);
         case NSLikePredicateOperatorType:
-            m_query.and_query(column.like(value, caseSensitive));
-            break;
+            return column.like(value, caseSensitive);
         default: {
-            if constexpr (is_any_v<C, Columns<String>, Columns<Lst<String>>, Columns<Set<String>>>) {
+            if constexpr (is_any_v<C, Columns<String>, Columns<Lst<String>>, Columns<Set<String>>, ColumnDictionaryKeys>) {
                 unsupportedOperator(RLMPropertyTypeString, operatorType);
             }
             else if constexpr (is_any_v<C, Columns<Binary>, Columns<Lst<Binary>>, Columns<Set<Binary>>>) {
@@ -726,10 +724,56 @@ Query make_diacritic_insensitive_constraint(NSPredicateOperatorType operatorType
                                @"Operator '%@' not supported for string queries on Dictionary.",
                                operatorName(operatorType));
             }
+            else {
+                static_assert(AlwaysFalse<C>::value, "unsupported column type");
+            }
         }
     }
 }
 
+template <typename C, typename T>
+void QueryBuilder::do_add_diacritic_sensitive_string_constraint(NSPredicateOperatorType operatorType,
+                                                                NSComparisonPredicateOptions predicateOptions,
+                                                                C&& column, T&& value) {
+    bool caseSensitive = !(predicateOptions & NSCaseInsensitivePredicateOption);
+    Query condition = make_diacritic_sensitive_constraint(operatorType, caseSensitive, column, value);
+
+    // Queries on Mixed used to coerce Strings to Binary and vice-versa. Core
+    // no longer does this, but we can maintain compatibility by doing the
+    // coercion and checking both
+    // NEXT-MAJOR: we should remove this and realign with core's behavior
+    if constexpr (is_any_v<C, Columns<Mixed>, Columns<Lst<Mixed>>, Columns<Set<Mixed>>, Columns<Dictionary>>) {
+        Mixed m = value;
+        if (!m.is_null()) {
+            if (m.get_type() == type_String) {
+                m = m.export_to_type<BinaryData>();
+            }
+            else {
+                m = m.export_to_type<StringData>();
+            }
+
+            // Equality and substring operations need (col == strValue OR col == binValue),
+            // but not equals needs (col != strValue AND col != binValue)
+            if (operatorType != NSNotEqualToPredicateOperatorType) {
+                condition.Or();
+            }
+
+            condition.and_query(make_diacritic_sensitive_constraint(operatorType, caseSensitive, column, m));
+        }
+    }
+    switch (operatorType) {
+        case NSBeginsWithPredicateOperatorType:
+        case NSEndsWithPredicateOperatorType:
+        case NSContainsPredicateOperatorType:
+            add_substring_constraint(value, std::move(condition));
+            break;
+
+        default:
+            m_query.and_query(std::move(condition));
+            break;
+    }
+}
+
 template <typename C, typename T>
 void QueryBuilder::add_diacritic_sensitive_string_constraint(NSPredicateOperatorType operatorType,
                                                              NSComparisonPredicateOptions predicateOptions,
@@ -1297,11 +1341,6 @@ KeyPath key_path_from_string(RLMSchema *schema, RLMObjectSchema *objectSchema, N
 
 #pragma mark Collection Operations
 
-// static_assert is always evaluated even if it's inside a if constexpr
-// unless the value is derived from the template argument, in which case it's
-// only evaluated if that branch is active
-template <CollectionOperation::Type> struct AlwaysFalse : std::false_type {};
-
 template <CollectionOperation::Type OperationType, typename Column>
 auto collection_operation_expr_2(Column&& column) {
     if constexpr (OperationType == CollectionOperation::Minimum) {
@@ -1317,7 +1356,8 @@ auto collection_operation_expr_2(Column&& column) {
         return column.average();
     }
     else {
-        static_assert(AlwaysFalse<OperationType>::value, "invalid operation type");
+        static_assert(AlwaysFalse<std::integral_constant<CollectionOperation::Type, OperationType>>::value,
+                      "invalid operation type");
     }
 }
 
@@ -1660,7 +1700,7 @@ bool is_self_value_for_key_path_function_expression(NSExpression *expression)
     ColumnReference collectionColumn = column_reference_from_key_path(key_path_from_string(m_schema, objectSchema, keyPath), true);
     RLMPrecondition(collectionColumn.property().dictionary, @"Invalid predicate",
                     @"Invalid keypath '%@': only dictionaries support subscript predicates.", functionExpression);
-    add_mixed_constraint(operatorType, options, collectionColumn.resolve<Dictionary>().key(mapKey.UTF8String), right.constantValue);
+    add_mixed_constraint(operatorType, options, std::move(collectionColumn.resolve<Dictionary>().key(mapKey.UTF8String)), right.constantValue);
 }
 
 void QueryBuilder::apply_function_expression(RLMObjectSchema *objectSchema, NSExpression *functionExpression,

Realm/RLMSyncConfiguration.mm

@@ -205,7 +205,7 @@ void RLMSetConfigInfoForClientResetCallbacks(realm::SyncConfig& syncConfig, RLMR
 
 - (id<RLMBSON>)partitionValue {
     if (!_config->partition_value.empty()) {
-        return RLMConvertBsonToRLMBSON(realm::bson::parse(_config->partition_value.c_str()));
+        return RLMConvertBsonToRLMBSON(realm::bson::parse(_config->partition_value));
     }
     return nil;
 }

Realm/RLMSyncManager.mm

@@ -73,7 +73,7 @@ RLMSyncLogLevel logLevelForLevel(Level logLevel) {
 #pragma mark - Loggers
 
 struct CocoaSyncLogger : public realm::util::Logger {
-    void do_log(Level, const std::string& message) override {
+    void do_log(const realm::util::LogCategory&, Level, const std::string& message) override {
         NSLog(@"Sync: %@", RLMStringDataToNSString(message));
     }
 };
@@ -86,7 +86,7 @@ void do_log(Level, const std::string& message) override {
 
 struct CallbackLogger : public realm::util::Logger {
     RLMSyncLogFunction logFn;
-    void do_log(Level level, const std::string& message) override {
+    void do_log(const realm::util::LogCategory&, Level level, const std::string& message) override {
         @autoreleasepool {
             logFn(logLevelForLevel(level), RLMStringDataToNSString(message));
         }
@@ -202,7 +202,7 @@ - (void)resetForTesting {
     _logger = nil;
     _authorizationHeaderName = nil;
     _customRequestHeaders = nil;
-    _syncManager->reset_for_testing();
+    _syncManager->tear_down_for_testing();
 }
 
 - (std::shared_ptr<realm::SyncManager>)syncManager {