Add Store.attach.

Author: greenrobot-team

objectbox/lib/src/native/store.dart

@@ -221,6 +221,59 @@ class Store {
     }
   }
 
+  /// Create a Dart store instance from an existing store openend in the same
+  /// path.
+  ///
+  /// Use this if you want to access the same store from multiple isolates.
+  /// This results in two (or more) isolates having access to the same
+  /// underlying native store. Concurrent access is ensured using implicit or
+  /// explicit transactions.
+  ///
+  /// When using from an isolate, make sure to [close] the store before the
+  /// isolate exits.
+  Store.attach(this._defs, String? directoryOrNull,
+      {bool queriesCaseSensitiveDefault = true})
+      : _weak = false,
+        _queriesCaseSensitiveDefault = queriesCaseSensitiveDefault,
+        _dbDir = path.context.canonicalize(
+            (directoryOrNull == null || directoryOrNull.isEmpty)
+                ? 'objectbox'
+                : directoryOrNull) {
+    // FIXME Refactor/combine with default constructor.
+    try {
+      final directory = (directoryOrNull == null || directoryOrNull.isEmpty)
+          ? 'objectbox'
+          : directoryOrNull;
+      final cStr = directory.toNativeUtf8();
+      try {
+        _cStore = C.store_attach(cStr.cast());
+      } finally {
+        malloc.free(cStr);
+      }
+
+      try {
+        checkObxPtr(_cStore, 'failed to create store');
+      } on ObjectBoxException catch (e) {
+        // Recognize common problems when trying to open/create a database
+        // 10199 = OBX_ERROR_STORAGE_GENERAL
+        // 13 = permissions denied, 30 = read-only filesystem
+        if (e.message.contains(OBX_ERROR_STORAGE_GENERAL.toString()) &&
+            e.message.contains('Dir does not exist') &&
+            (e.message.endsWith(' (13)') || e.message.endsWith(' (30)'))) {
+          throw ObjectBoxException(e.message +
+              ' - this usually indicates a problem with permissions; '
+                  "if you're using Flutter you may need to use "
+                  'getApplicationDocumentsDirectory() from the path_provider '
+                  'package, see example/README.md');
+        }
+        rethrow;
+      }
+    } catch (e) {
+      _reader.clear();
+      rethrow;
+    }
+  }
+
   /// Returns a store reference you can use to create a new store instance with
   /// a single underlying native store. See [Store.fromReference] for more details.
   ByteData get reference => _reference;

objectbox/test/isolates_test.dart

@@ -46,60 +46,84 @@ void main() {
     receivePort.close();
   });
 
-  /// Work with a single store across multiple isolates.
-  test('single store in multiple isolates', () async {
-    final receivePort = ReceivePort();
-    final isolate =
-        await Isolate.spawn(createDataIsolate, receivePort.sendPort);
-
-    final sendPortCompleter = Completer<SendPort>();
-    late Completer<dynamic> responseCompleter;
-    receivePort.listen((dynamic data) {
-      if (data is SendPort) {
-        sendPortCompleter.complete(data);
-      } else {
-        print('Main received: $data');
-        responseCompleter.complete(data);
-      }
-    });
+  /// Work with a single store across multiple isolates using
+  /// the legacy way of passing a pointer reference to the isolate.
+  test('single store using reference', () async {
+    final storeCreator = (dynamic msg) =>
+        Store.fromReference(getObjectBoxModel(), msg as ByteData);
+    await testUsingStoreFromIsolate(storeCreator, (env) => env.store.reference);
+  });
 
-    // Receive the SendPort from the Isolate
-    SendPort sendPort = await sendPortCompleter.future;
+  /// Work with a single store across multiple isolates using
+  /// the directory path to attach to an existing store.
+  test('single store using attach', () async {
+    final storeCreator =
+        (dynamic msg) => Store.attach(getObjectBoxModel(), msg as String);
+    await testUsingStoreFromIsolate(storeCreator, (env) => env.dir.path);
+  });
+}
 
-    final call = (dynamic message) {
-      responseCompleter = Completer<dynamic>();
-      sendPort.send(message);
-      return responseCompleter.future;
-    };
+class IsolateInitMessage {
+  SendPort sendPort;
+  Store Function(dynamic) storeCreator;
 
-    // Pass the store to the isolate
-    final env = TestEnv('isolates');
-    expect(await call(env.store.reference), equals('store set'));
+  IsolateInitMessage(this.sendPort, this.storeCreator);
+}
 
-    {
-      // check simple box operations
-      expect(env.box.isEmpty(), isTrue);
-      expect(await call(['put', 'Foo']), equals(1)); // returns inserted id = 1
-      expect(env.box.get(1)!.tString, equals('Foo'));
+Future<void> testUsingStoreFromIsolate(Store Function(dynamic) storeCreator,
+    dynamic Function(TestEnv) storeRefGetter) async {
+  final receivePort = ReceivePort();
+  final initMessage = IsolateInitMessage(receivePort.sendPort, storeCreator);
+  final isolate = await Isolate.spawn(createDataIsolate, initMessage);
+
+  final sendPortCompleter = Completer<SendPort>();
+  late Completer<dynamic> responseCompleter;
+  receivePort.listen((dynamic data) {
+    if (data is SendPort) {
+      sendPortCompleter.complete(data);
+    } else {
+      print('Main received: $data');
+      responseCompleter.complete(data);
     }
+  });
 
-    {
-      // verify that query streams (using observers) work fine across isolates
-      final queryStream = env.box.query().watch();
-      // starts a subscription
-      final futureFirst = queryStream.map((q) => q.find()).first;
-      expect(await call(['put', 'Bar']), equals(2));
-      List<TestEntity> found = await futureFirst.timeout(defaultTimeout);
-      expect(found.length, equals(2));
-      expect(found.last.tString, equals('Bar'));
-    }
+  // Receive the SendPort from the Isolate
+  SendPort sendPort = await sendPortCompleter.future;
+
+  final call = (dynamic message) {
+    responseCompleter = Completer<dynamic>();
+    sendPort.send(message);
+    return responseCompleter.future;
+  };
+
+  // FIXME Send path instead of reference when using attach.
+  // Pass the store to the isolate
+  final env = TestEnv('isolates');
+  expect(await call(storeRefGetter(env)), equals('store set'));
+
+  {
+    // check simple box operations
+    expect(env.box.isEmpty(), isTrue);
+    expect(await call(['put', 'Foo']), equals(1)); // returns inserted id = 1
+    expect(env.box.get(1)!.tString, equals('Foo'));
+  }
+
+  {
+    // verify that query streams (using observers) work fine across isolates
+    final queryStream = env.box.query().watch();
+    // starts a subscription
+    final futureFirst = queryStream.map((q) => q.find()).first;
+    expect(await call(['put', 'Bar']), equals(2));
+    List<TestEntity> found = await futureFirst.timeout(defaultTimeout);
+    expect(found.length, equals(2));
+    expect(found.last.tString, equals('Bar'));
+  }
 
-    expect(await call(['close']), equals('done'));
+  expect(await call(['close']), equals('done'));
 
-    isolate.kill();
-    receivePort.close();
-    env.close();
-  });
+  isolate.kill();
+  receivePort.close();
+  env.close();
 }
 
 // Echoes back any received message.
@@ -119,19 +143,20 @@ void echoIsolate(SendPort sendPort) async {
 }
 
 // Creates data in the background, in the [Store] received as the first message.
-void createDataIsolate(SendPort sendPort) async {
+void createDataIsolate(IsolateInitMessage initMessage) async {
   // Open the ReceivePort to listen for incoming messages
   final port = ReceivePort();
 
   // Send the port where the main isolate can contact us
+  final sendPort = initMessage.sendPort;
   sendPort.send(port.sendPort);
 
   Store? store;
   // Listen for messages
   await for (final msg in port) {
     if (store == null) {
       // first message data is Store's C pointer address
-      store = Store.fromReference(getObjectBoxModel(), msg as ByteData);
+      store = initMessage.storeCreator(msg);
       sendPort.send('store set');
     } else {
       print('Isolate received: $msg');