mirror of https://github.com/AMT-Cheif/drift.git
111 lines
4.0 KiB
Markdown
111 lines
4.0 KiB
Markdown
This package has been deprecated! Consider migrating to new sqlite packages depending on your setup:
|
|
|
|
- You use moor to build Flutter apps: Remove `moor_ffi` from your dependencies and add `sqlite3_flutter_libs`
|
|
instead. Also, replace the following imports:
|
|
- change `package:moor_ffi/moor_ffi.dart` to `package:moor/ffi.dart`
|
|
- change `package:moor_ffi/open_helper.dart` to `package:sqlite3/open.dart`
|
|
- You use moor, but without Flutter: Just drop the `moor_ffi` dependency and use the new
|
|
`package:moor/ffi.dart` library. You need to make sure that a dynamic sqlite3 library is
|
|
available at runtime.
|
|
- You don't use moor, but you do use Flutter: Depend on `sqlite3` and `sqlite3_flutter_libs`. The
|
|
`sqlite3` package contains the new Dart apis to use sqlite3.
|
|
- You don't use the main moor package or Flutter: Just depend on the `sqlite3` package and make sure that a
|
|
dynamic sqlite3 library is available at runtime
|
|
|
|
# moor_ffi
|
|
|
|
Dart bindings to sqlite by using `dart:ffi`. This library contains utils to make
|
|
integration with [moor](https://pub.dev/packages/moor) easier, but it can also be used
|
|
as a standalone package. It also doesn't depend on Flutter, so it can be used on Dart VM
|
|
applications as well.
|
|
|
|
## Supported platforms
|
|
You can make this library work on any platform that lets you obtain a `DynamicLibrary`
|
|
in which sqlite's symbols are available (see below).
|
|
|
|
Out of the box, this library supports all platforms where `sqlite3` is installed:
|
|
- iOS: Yes
|
|
- macOS: Yes
|
|
- Linux: Available on most distros
|
|
- Windows: Additional setup is required
|
|
- Android: Yes when used with Flutter, this library includes the necessary native libraries on Android
|
|
|
|
### On other platforms
|
|
Using this library on platforms that are not supported out of the box is fairly
|
|
straightforward. For instance, if you release your own `sqlite3.so` next to your application,
|
|
you could use
|
|
```dart
|
|
import 'dart:ffi';
|
|
import 'dart:io';
|
|
import 'package:moor_ffi/database.dart';
|
|
import 'package:moor_ffi/open_helper.dart';
|
|
|
|
void main() {
|
|
open.overrideFor(OperatingSystem.linux, _openOnLinux);
|
|
|
|
final db = Database.memory();
|
|
db.close();
|
|
}
|
|
|
|
DynamicLibrary _openOnLinux() {
|
|
final script = File(Platform.script.toFilePath());
|
|
final libraryNextToScript = File('${script.path}/sqlite3.so');
|
|
return DynamicLibrary.open(libraryNextToScript.path);
|
|
}
|
|
```
|
|
Just be sure to first override the behavior and then open the database. Further,
|
|
if you want to use the isolate api, you can only use a static method or a top-level
|
|
function to open the library. For Windows, a similar setup with a `sqlite3.dll` library
|
|
should work.
|
|
|
|
### Supported datatypes
|
|
This library supports `null`, `int`, `double`, `String` and `Uint8List` to bind args.
|
|
Returned columns from select statements will have the same types.
|
|
|
|
## Using without moor
|
|
```dart
|
|
import 'package:moor_ffi/database.dart';
|
|
|
|
void main() {
|
|
final database = Database.memory();
|
|
// run some database operations. See the example for details
|
|
database.close();
|
|
}
|
|
```
|
|
|
|
Be sure to __always__ call `Database.close` to avoid memory leaks!
|
|
|
|
## Using with moor
|
|
If you're migrating an existing project using `moor_flutter`, see the
|
|
[documentation](https://moor.simonbinder.eu/docs/other-engines/vm/#migrating-from-moor-flutter-to-moor-ffi).
|
|
|
|
Add both `moor` and `moor_ffi` to your pubspec:
|
|
```yaml
|
|
dependencies:
|
|
moor: ^2.0.0
|
|
moor_ffi: ^0.2.0
|
|
dev_dependencies:
|
|
moor_generator: ^2.0.0
|
|
```
|
|
|
|
You can then use a `VmDatabase` as an executor:
|
|
```dart
|
|
@UseMoor(...)
|
|
class MyDatabase extends _$MyDatabase {
|
|
|
|
MyDatabase(): super(VmDatabase(File('app.db')));
|
|
}
|
|
```
|
|
If you need to find an appropriate directory for the database file, you can use the `LazyDatabase` wrapper
|
|
from moor. It can be used to create the inner `VmDatabase` asynchronously:
|
|
```dart
|
|
import 'package:path_provider/path_provider.dart';
|
|
import 'package:path/path.dart' as p;
|
|
|
|
// use this instead of VmDatabase(...)
|
|
LazyDatabase(() async {
|
|
final dbFolder = await getApplicationDocumentsDirectory();
|
|
final file = File(p.join(dbFolder.path, 'app.db'));
|
|
return VmDatabase(file);
|
|
});
|
|
``` |