realm delete many

.vscode/settings.json

@@ -96,5 +96,6 @@
         "flutter/realm_flutter/ios/src/**": true,
         "flutter/realm_flutter/lib/**": true,
         "flutter/realm_flutter/test/**": true
-    }
+    },
+    "dart.lineLength": 160
 }

lib/src/native/realm_core.dart

@@ -317,7 +317,7 @@ class _RealmCore {
     });
   }
 
-  void removeRealmObject(RealmObject object) {
+  void deleteRealmObject(RealmObject object) {
     _realmLib.invokeGetBool(() => _realmLib.realm_object_delete(object.handle._pointer));
   }
 
@@ -424,6 +424,14 @@ class _RealmCore {
       _realmLib.invokeGetBool(() => _realmLib.realm_list_insert(list.handle._pointer, index, realm_value.ref));
     });
   }
+
+  void listDeleteAll(RealmList list) {
+    _realmLib.invokeGetBool(() => _realmLib.realm_list_remove_all(list.handle._pointer));
+  }
+
+  void resultsDeleteAll(RealmResults results) {
+    _realmLib.invokeGetBool(() => _realmLib.realm_results_delete_all(results.handle._pointer));
+  }
 }
 
 class LastError {

lib/src/realm_class.dart

@@ -83,14 +83,37 @@ class Realm {
     return object;
   }
 
+  /// Delete given [RealmObject] from Realm database.
+  /// Throws [RealmException] on error.
+  void delete<T extends RealmObject>(T object) {
+    try {
+      realmCore.deleteRealmObject(object);
+    } catch (e) {
+      throw RealmException("Error deleting object from databse. Error: $e");
+    }
+  }
+
+  /// Deletes [RealmObject] items in given collection from Realm database.
+  void deleteMany<T extends RealmObject>(Iterable<T> items) {
+    if (items is RealmResults<T>) {
+      realmCore.resultsDeleteAll(items);
+    } else if (items is RealmList<T>) {
+      realmCore.listDeleteAll(items);
+    } else {
+      for (T realmObject in items) {
+        realmCore.deleteRealmObject(realmObject);
+      }
+    }
+  }
+
   void addAll<T extends RealmObject>(Iterable<T> items) {
     for (final i in items) {
       add(i);
     }
   }
 
   void remove<T extends RealmObject>(T object) {
-    realmCore.removeRealmObject(object);
+    realmCore.deleteRealmObject(object);
   }
 
   bool get _isInTransaction => realmCore.getIsWritable(this);

lib/src/results.dart

@@ -91,7 +91,7 @@ class _ResultsList<T extends RealmObject> extends collection.ListBase<T> {
 /// Instances of this class are typically live collections returned by [Realm.objects]
 /// that will update as new objects are either added to or deleted from the Realm
 /// that match the underlying query.
-class RealmResults<T extends RealmObject> {
+class RealmResults<T extends RealmObject> extends collection.IterableBase<T> {
   late final RealmResultsHandle _handle;
   late final Realm _realm;
   // RealmResults _results;
@@ -143,16 +143,19 @@ class RealmResults<T extends RealmObject> {
   // }
 
   /// Returns `true` if the Results collection is empty
-  bool isEmpty() {
-    return length == 0;
-  }
+  @override
+  bool get isEmpty => length == 0;
+
+  @override
+  Iterator<T> get iterator => _RealmResultsIterator(this);
 
   /// Returns `true` if this Results collection has not been deleted and is part of a valid Realm.
   ///
   /// Accessing an invalid Results collection will throw an [RealmException]
   // bool get isValid => _results.isValid();
 
   /// Returns the number of values in the Results collection.
+  @override
   int get length => realmCore.getResultsCount(this);
 
   /// Returns a human-readable description of the objects contained in the collection.
@@ -208,3 +211,29 @@ extension RealmResultsInternal on RealmResults {
     return RealmResults<T>._(handle, realm);
   }
 }
+
+class _RealmResultsIterator<T extends RealmObject> implements Iterator<T> {
+  final RealmResults<T> _results;
+  int _index;
+  T? _current;
+
+  _RealmResultsIterator(RealmResults<T> results)
+      : _results = results,
+        _index = -1;
+
+  @override
+  T get current => _current as T;
+
+  @override
+  bool moveNext() {
+    int length = _results.length;
+    _index++;
+    if (_index >= length) {
+      _current = null;
+      return false;
+    }
+    _current = _results[_index];
+
+    return true;
+  }
+}

test/realm_test.dart

@@ -439,7 +439,7 @@ Future<void> main([List<String>? args]) async {
       expect(car, isNull);
     });
 
-    test('Realm remove object', () {
+    test('Realm delete object', () {
       var config = Configuration([Car.schema]);
       var realm = Realm(config);
 
@@ -449,7 +449,7 @@ Future<void> main([List<String>? args]) async {
       final car1 = realm.find<Car>("SomeNewNonExistingValue");
       expect(car1, isNotNull);
 
-      realm.write(() => realm.remove(car1!));
+      realm.write(() => realm.delete(car1!));
 
       var car2 = realm.find<Car>("SomeNewNonExistingValue");
       expect(car2, isNull);
@@ -475,7 +475,7 @@ Future<void> main([List<String>? args]) async {
 
       expect(cars.length, 1);
 
-      realm.write(() => realm.remove(car));
+      realm.write(() => realm.delete(car));
 
       expect(cars.length, 0);
     });
@@ -485,16 +485,16 @@ Future<void> main([List<String>? args]) async {
       var realm = Realm(config);
 
       var cars = realm.all<Car>();
-      expect(cars.isEmpty(), true);
+      expect(cars.isEmpty, true);
 
       final car = Car();
       realm.write(() => realm.add(car));
 
-      expect(cars.isEmpty(), false);
+      expect(cars.isEmpty, false);
 
-      realm.write(() => realm.remove(car));
+      realm.write(() => realm.delete(car));
 
-      expect(cars.isEmpty(), true);
+      expect(cars.isEmpty, true);
     });
 
     test('Results get by index', () {
@@ -679,5 +679,182 @@ Future<void> main([List<String>? args]) async {
       expect(() => realm.write(() => players[-1] = Person()), throws<RealmException>("Index out of range"));
       expect(() => realm.write(() => players[800] = Person()), throws<RealmException>());
     });
+
+    test('Realm.deleteMany from list', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create two teams
+      final teamOne = Team()..name = "Team one";
+      final teamTwo = Team()..name = "Team two";
+      final teamThree = Team()..name = "Team three";
+      realm.write(() {
+        realm.add(teamOne);
+        realm.add(teamTwo);
+        realm.add(teamThree);
+      });
+
+      //Ensure the teams exist in realm
+      var teams = realm.all<Team>();
+      expect(teams.length, 3);
+
+      //Delete teams one and three from realm
+      realm.write(() => realm.deleteMany([teamOne, teamThree]));
+
+      //Ensure both teams are deleted and only teamTwo has left
+      expect(teams.length, 1);
+      expect(teams[0].name, teamTwo.name);
+    });
+
+    test('Realm.deleteMany from realmList', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create a team
+      final team = Team()..name = "Ferrari";
+      realm.write(() => realm.add(team));
+
+      //Add players to the team
+      final newPlayers = [
+        Person()..name = "Michael Schumacher",
+        Person()..name = "Sebastian Vettel",
+        Person()..name = "Kimi Räikkönen",
+      ];
+      realm.write(() => team.players.addAll(newPlayers));
+
+      //Ensure the team exists in realm
+      var teams = realm.all<Team>();
+      expect(teams.length, 1);
+
+      //Delete team players
+      realm.write(() => realm.deleteMany(teams[0].players));
+
+      //Ensure players are deleted from collection
+      expect(teams[0].players.length, 0);
+
+      //Reload all persons from realm and ensure they are deleted
+      final allPersons = realm.all<Person>();
+      expect(allPersons.length, 0);
+    });
+
+    test('Realm.deleteMany from realmList referenced by two objects', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create two teams
+      final teamOne = Team()..name = "Ferrari";
+      final teamTwo = Team()..name = "Maserati";
+      realm.write(() {
+        realm.add(teamOne);
+        realm.add(teamTwo);
+      });
+
+      //Create common players list for both teams
+      final newPlayers = [
+        Person()..name = "Michael Schumacher",
+        Person()..name = "Sebastian Vettel",
+        Person()..name = "Kimi Räikkönen",
+      ];
+      realm.write(() {
+        teamOne.players.addAll(newPlayers);
+        teamTwo.players.addAll(newPlayers);
+      });
+
+      //Ensule teams exist in realm
+      var teams = realm.all<Team>();
+      expect(teams.length, 2);
+
+      //Delete all players in a team from realm
+      realm.write(() => realm.deleteMany(teams[0].players));
+
+      //Ensure all players are deleted from collection
+      expect(teams[0].players.length, 0);
+
+      //Reload all persons from realm and ensure they are deleted
+      final allPersons = realm.all<Person>();
+      expect(allPersons.length, 0);
+    });
+
+    test('Realm.deleteMany from RealmResults', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create two teams
+      realm.write(() {
+        realm.add(Team()..name = "Ferrari");
+        realm.add(Team()..name = "Maserati");
+      });
+
+      //Ensule teams exist in realm
+      var teams = realm.all<Team>();
+      expect(teams.length, 2);
+
+      //Delete all objects in realmResults from realm
+      realm.write(() => realm.deleteMany(teams));
+      expect(teams.length, 0);
+
+      //Reload teams from realm and ensure they are deleted
+      teams = realm.all<Team>();
+      expect(teams.length, 0);
+    });
+
+    test('Realm.deleteMany from realmList after realm is closed', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create a team
+      final team = Team()..name = "Ferrari";
+      realm.write(() => realm.add(team));
+
+      //Add players to the team
+      final newPlayers = [
+        Person()..name = "Michael Schumacher",
+        Person()..name = "Sebastian Vettel",
+        Person()..name = "Kimi Räikkönen",
+      ];
+      realm.write(() => team.players.addAll(newPlayers));
+
+      //Ensure team exists in realm
+      var teams = realm.all<Team>();
+      expect(teams.length, 1);
+
+      //Try to delete team players while realm is closed
+      final players = teams[0].players;
+      expect(
+          () => realm.write(() {
+                realm.close();
+                realm.deleteMany(players);
+              }),
+          throws<RealmException>());
+
+      //Ensure all persons still exists in realm
+      realm = Realm(config);
+      final allPersons = realm.all<Person>();
+      expect(allPersons.length, 3);
+    });
+
+    test('RealmResults iteration test', () {
+      var config = Configuration([Team.schema, Person.schema]);
+      var realm = Realm(config);
+
+      //Create two teams
+      realm.write(() {
+        realm.add(Team()..name = "team One");
+        realm.add(Team()..name = "team Two");
+      });
+
+      //Reload teams from realm and ensure they exist
+      var teams = realm.all<Team>();
+      expect(teams.length, 2);
+
+      //Iterate through teams and add realm objects to a list
+      List<Team> list = [];
+      for (Team team in teams) {
+        list.add(team);
+      }
+
+      //Ensure list size is the same like teams collection size
+      expect(list.length, teams.length);
+    });
   });
 }