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 realmResultsRemoveAll(RealmResults results) {
+ _realmLib.invokeGetBool(() => _realmLib.realm_results_delete_all(results.handle._pointer));
+ }
 }
 
 class LastError {

lib/src/realm_class.dart

@@ -83,8 +83,32 @@ class Realm {
  return object;
  }
 
+ /// Removes given [RealmObject] from Realm database.
+ /// Throws [RealmException] on error.
  void remove<T extends RealmObject>(T object) {
- realmCore.removeRealmObject(object);
+ try {
+ realmCore.removeRealmObject(object);
+ } catch (e) {
+ throw RealmException("Error deleting object from databse. Error: $e");
+ }
+ }
+
+ /// Removes [RealmObject] items in given collection from Realm database.
+ /// Throws [RealmException] on error.
+ void removeMany<T extends RealmObject>(Iterable<T> items) {
+ try {
+ if (items is RealmResults<T>) {
+ realmCore.realmResultsRemoveAll(items);
+ } else if (items is RealmList<T>) {
+ realmCore.realmListRemoveAll(items);
+ } else {
+ for (T realmObject in items) {
+ realmCore.removeRealmObject(realmObject);
+ }
+ }
+ } catch (e) {
+ throw RealmException("Error deleting objects from databse. Error: $e");
+ }
  }
 
  bool get _isInTransaction => realmCore.getIsWritable(this);

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;
@@ -142,16 +142,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.
@@ -207,3 +210,33 @@ extension RealmResultsInternal on RealmResults {
  return RealmResults<T>._(handle, realm);
  }
 }
+
+class _RealmResultsIterator<T extends RealmObject> implements Iterator<T> {
+ final RealmResults<T> _results;
+ final int _length;
+ int _index;
+ T? _current;
+
+ _RealmResultsIterator(RealmResults<T> results)
+ : _results = results,
+ _length = results.length,
+ _index = 0;
+
+ @override
+ T get current => _current as T;
+
+ @override
+ bool moveNext() {
+ int length = _results.length;
+ if (_length != length) {
+ throw ConcurrentModificationError(_results);
+ }
+ if (_index >= length) {
+ _current = null;
+ return false;
+ }
+ _current = _results[_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,166 @@ 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));
+
+ //Reload teams from database and ensure they are removed
+ 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 collection
+ expect(teams[0].players.length, 0);
+
+ //Reload persons from database and ensure they are removed
+ 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 collection
+ expect(teams[0].players.length, 0);
+
+ //Reload persons from database and ensure they are removed
+ 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));
+ expect(teams.length, 0);
+
+ //Reload teams from databse and ensure they are removed
+ 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 database
+ realm = Realm(config);
+ final personsFromDB = realm.all<Person>();
+ expect(personsFromDB.length, 3);
+ });
+
+ test('RealmResults iteration test', () {
+ 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";
+ realm.write(() => {realm.add(teamOne), realm.add(teamTwo)});
+
+ //Get teams from database
+ 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
+ expect(list.length, teams.length);
+ });
  });
 }