realm delete many

lib/src/native/realm_core.dart

@@ -384,6 +384,14 @@ class _RealmCore {
  });
  }
 
+ void realmListRemoveAll(RealmList list) {
+ _realmLib.invokeGetBool(
+ () => _realmLib.realm_list_remove_all(list.handle._pointer));
+ }
+
+ void realmResultsDeleteAll(RealmResults results) {
+ _realmLib.invokeGetBool(() => _realmLib.realm_results_delete_all(results.handle._pointer));
+ }
 }
 
 class LastError {

lib/src/realm_class.dart

@@ -87,6 +87,22 @@ class Realm {
  realmCore.removeRealmObject(object);
  }
 
+ void removeMany<T extends RealmObject>(Iterable<T> list) {
+ try {
+ if (list is RealmResults<T>) {
+ realmCore.realmResultsDeleteAll(list);
+ } else if (list is RealmList<T>) {
+ realmCore.realmListRemoveAll(list);
+ } else {
+ for (T realmObject in list) {
+ realmCore.removeRealmObject(realmObject);
+ }
+ }
+ } catch (e) {
+ throw RealmException("Error deleting objects from databse. Error: $e");
+ }
+ }
+
  bool get _isInTransaction => realmCore.getIsWritable(this);
 
  void write(void Function() writeCallback) {

lib/src/results.dart

@@ -95,7 +95,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;
@@ -135,25 +135,28 @@ class RealmResults<T extends RealmObject> {
  // List<T> asList() {
  // return _ResultsList(this);
  // }
-
+ 
  /// Returns the index of the given object in the Results collection.
  // int indexOf(T value) {
  // return _results.indexOf(value);
  // }
 
  /// 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.
  // String get description => _results.description;
 
@@ -207,3 +210,34 @@ extension RealmResultsInternal on RealmResults {
  return RealmResults<T>._(handle, realm);
  }
 }
+
+class RealmResultsIterator<T extends RealmObject> implements Iterator<T> {
+ final Iterable<T> _iterable;
+ final int _length;
+ int _index;
+ T? _current;
+
+ RealmResultsIterator(Iterable<T> iterable)
+ : _iterable = iterable,
+ _length = iterable.length, 
+ _index = 0;
+
+ @override
+ T get current => _current as T;
+
+ @override
+ bool moveNext() {
+ int length = _iterable.length;
+ if (_length != length) {
+ throw ConcurrentModificationError(_iterable);
+ }
+ if (_index >= length) {
+ _current = null;
+ return false;
+ }
+ _current = _iterable.elementAt(_index);
+ _index++;
+ return true;
+ }
+}
+

test/realm_test.dart

@@ -464,16 +464,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));
 
- expect(cars.isEmpty(), true);
+ expect(cars.isEmpty, true);
  });
 
  test('Results get by index', () {
@@ -552,5 +552,135 @@ 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 RemoveMany from List', () {
+ 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)});
+
+ var teams = realm.all<Team>();
+ expect(teams.length, 2);
+
+ //Convert RealmResults to List (asList should be implemented)
+ List<Team> list = [];
+ int itemsCount = teams.length;
+ for (var i = 0; i < itemsCount; i++) {
+ list.add(teams[i]);
+ }
+
+ realm.write(() => realm.removeMany(list));
+ teams = realm.all<Team>();
+ expect(teams.length, 0);
+ });
+
+ test('Realm RemoveMany 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
+ realm.write(() => team.players.addAll([
+ Person()..name = "Michael Schumacher",
+ Person()..name = "Sebastian Vettel",
+ Person()..name = "Kimi Räikkönen"
+ ]));
+
+ //Ensure the Tema exists in DB
+ var teams = realm.all<Team>();
+ expect(teams.length, 1);
+
+ //Remove team players
+ realm.write(() => realm.removeMany(teams[0].players));
+
+ //Ensure persons are deleted from DB
+ final personsFromDB = realm.all<Person>();
+ expect(personsFromDB.length, 0);
+ });
+
+ test('Realm RemoveMany 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
+ List<Person> players = [
+ Person()..name = "Michael Schumacher",
+ Person()..name = "Sebastian Vettel",
+ Person()..name = "Kimi Räikkönen"
+ ];
+ realm.write(() =>
+ {teamOne.players.addAll(players), teamTwo.players.addAll(players)});
+
+ //Ensule teams exist in DB
+ var teams = realm.all<Team>();
+ expect(teams.length, 2);
+
+ //Remove all players in a team
+ realm.write(() => realm.removeMany(teams[0].players));
+
+ //Ensure all persons are deleted from DB
+ final personsFromDB = realm.all<Person>();
+ expect(personsFromDB.length, 0);
+ });
+
+ test('Realm RemoveMany from RealmResults', () {
+ 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)});
+
+ //Ensule teams exist in DB
+ var teams = realm.all<Team>();
+ expect(teams.length, 2);
+
+ //Remove all objects in RealmResults from DB
+ realm.write(() => realm.removeMany(teams));
+ teams = realm.all<Team>();
+ expect(teams.length, 0);
+ });
+
+ test('Realm RemoveMany from RealmList in closed realm', () {
+ var config = Configuration([Team.schema, Person.schema]);
+ var realm = Realm(config);
+
+ final team = Team()..name = "Ferrari";
+ realm.write(() => realm.add(team));
+
+ realm.write(() => team.players.addAll([
+ Person()..name = "Michael Schumacher",
+ Person()..name = "Sebastian Vettel",
+ Person()..name = "Kimi Räikkönen"
+ ]));
+
+ //Ensure team exists
+ var teams = realm.all<Team>();
+ expect(teams.length, 1);
+
+ //Try to delete team players while realm is closed
+ final playersToDelete = teams[0].players;
+ expect(() => realm.write(() => {realm.close(),
+ realm.removeMany(playersToDelete)}),
+ throws<RealmException>("Error deleting objects from databse"));
+
+ //Ensure all persons still exists in DB
+ realm = Realm(config);
+ final personsFromDB = realm.all<Person>();
+ expect(personsFromDB.length, 3);
+
+ });
  });
 }