Drift

https://drift.simonbinder.eu
Admin
Drift is a reactive persistence library for relational databases in Dart and Flutter applications,...
Tokens:126,074
Snippets:974
Trust Score:7.3
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Manual web setup with WasmDatabase.open

Source: https://drift.simonbinder.eu/platforms/web

Use this snippet for manual setup of drift on the web when you need more control over storage APIs. It uses WasmDatabase.open and returns a DatabaseConnection.delayed. The code also shows how to handle missing browser features and how to use the connection in a database class.

```dart
DatabaseConnection connectOnWeb() {
  return DatabaseConnection.delayed(
    Future(() async {
      final result = await WasmDatabase.open(
        databaseName: 'my_app_db', // prefer to only use valid identifiers here
        sqlite3Uri: Uri.parse('sqlite3.wasm'),
        driftWorkerUri: Uri.parse('drift_worker.dart.js'),
      );

      if (result.missingFeatures.isNotEmpty) {
        // Depending how central local persistence is to your app, you may want
        // to show a warning to the user if only unrealiable implemetentations
        // are available.
        print(
          'Using ${result.chosenImplementation} due to missing browser '
          'features: ${result.missingFeatures}',
        );
      }

      return result.resolvedExecutor;
    }),
  );
}

// You can then use this method to open your database:
class MyWebDatabase extends _$MyWebDatabase {
  MyWebDatabase._(super.e);

  factory MyWebDatabase() => MyWebDatabase._(connectOnWeb());
  // ...
}

```

--------------------------------

### users.drift example

Source: https://drift.simonbinder.eu/generation_options/modular

Example users.drift file with a table definition and a query. In modular mode, the query is not generated as a method on the database but as part of the UsersDrift accessor.

```sql
CREATE TABLE users (
  id INTEGER NOT NULL,
  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  name TEXT NOT NULL,
  is_admin BOOLEAN NOT NULL DEFAULT FALSE
);

findUsers($predicate = TRUE): SELECT * FROM users WHERE $predicate;

```

--------------------------------

### Raw query example

Source: https://drift.simonbinder.eu/guides/migrating_to_drift

Example of a raw query using the old sqflite-style API before migration.

```dart
database.rawQuery('SELECT * FROM Test WHERE value > ?', [12]);
```

--------------------------------

### Android SQLite Database Setup with Drift

Source: https://drift.simonbinder.eu/setup

Use this snippet to set up a local Drift database on Android. It includes workarounds for sqlite3's /tmp usage and older Android library loading issues. The example defines a TodoItems table and opens the database using NativeDatabase.createInBackground.

```dart
import 'package:drift/drift.dart';
import 'dart:io';
import 'package:drift/native.dart';

part 'database.g.dart';

class TodoItems extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get title => text().withLength(min: 6, max: 32)();
  TextColumn get content => text().named('body')();
  DateTimeColumn get createdAt => dateTime().nullable()();
}

@DriftDatabase(tables: [TodoItems])
class AppDatabase extends _$AppDatabase {
  // After generating code, this class needs to define a `schemaVersion` getter
  // and a constructor telling drift where the database should be stored.
  // These are described in the getting started guide: https://drift.simonbinder.eu/setup/
  AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());

  @override
  int get schemaVersion => 1;

  static QueryExecutor _openConnection() {
    return NativeDatabase.createInBackground(File('path/to/your/database'));
  }
}

```

--------------------------------

### Setup database.dart with @DriftDatabase

Source: https://drift.simonbinder.eu/sql_api/drift_files

Sets up a drift database class that includes a drift file. Uses an in-memory database and requires the generated `_$MyDb` superclass from `database.g.dart`.

```dart
import 'package:drift/drift.dart';
import 'package:drift/native.dart';

part 'database.g.dart';

@DriftDatabase(include: {'tables.drift'})
class MyDb extends _$MyDb {
  // This example creates a simple in-memory database (without actual
  // persistence).
  // To store data, see the database setups from other "Getting started" guides.
  MyDb() : super(NativeDatabase.memory());

  @override
  int get schemaVersion => 1;
}

```

--------------------------------

### Set encryption key with NativeDatabase setup

Source: https://drift.simonbinder.eu/platforms/encryption

Sets an encryption key before drift uses the database. The setup parameter runs before drift uses the database in any way, so this is a good place to execute the PRAGMA key statement.

```dart
NativeDatabase.createInBackground(
  myDatabaseFile,
  setup: (rawDb) {
    rawDb.execute("PRAGMA key = 'passphrase';");
  },
);

```

--------------------------------

### Configure drift_dev options in build.yaml

Source: https://drift.simonbinder.eu/generation_options

Create a build.yaml file in the project root to set drift_dev options. The example enables store_date_time_values_as_text.

```yaml
# build.yaml. This file is quite powerful, see https://pub.dev/packages/build_config

targets:
  $default:
    builders:
      drift_dev:
        options:
          store_date_time_values_as_text: true
```

--------------------------------

### Export and run drift schema startup code

Source: https://drift.simonbinder.eu/migrations/exports

First, dump the internal code drift uses to run your database to a file. Then run that file to reproduce the error and get a compiler explanation of unsupported library paths.

```bash
dart run drift_dev make-migrations --export-schema-startup-code=schema_description.dart
```

```bash
dart run schema_description.dart
```

--------------------------------

### Write a step-by-step migration with stepByStep

Source: https://drift.simonbinder.eu/migrations

Example of a migration written after running make-migrations. It uses the generated database.steps.dart file and the stepByStep API to define the upgrade from version 1 to 2, creating the groups table.

```dart
import 'package:drift/drift.dart';

import 'database.steps.dart';

part 'database.g.dart';

@DriftDatabase(...)
class MyDatabase extends _$MyDatabase {
  MyDatabase(super.e);

  @override
  int get schemaVersion => 2; // bump because the tables have changed.

  @override
  MigrationStrategy get migration {
    return MigrationStrategy(
      onUpgrade: _schemaUpgrade,
    );
  }
}

extension Migrations on GeneratedDatabase {
  // Extracting the `stepByStep` call into a static field or method ensures that you're not
  // accidentally referring to the current database schema (via a getter on the database class).
  // This ensures that each step brings the database into the correct snapshot.
  OnUpgrade get _schemaUpgrade => stepByStep(
    from1To2: (m, schema) async {
      await m.createTable(schema.groups);
    },
  );
}
```

--------------------------------

### Project structure after modular generation

Source: https://drift.simonbinder.eu/generation_options/modular

Shows the file structure after enabling modular generation, where each input file gets a corresponding .drift.dart file.

```text
lib/src/database/
├── database.dart
├── database.drift.dart
├── tables/
│   ├── users.drift
│   ├── users.drift.dart
│   ├── settings.drift
│   ├── settings.drift.dart
│   └── ...
└── views/
    ├── friends.drift
    ├── friends.drift.dart
    ├── categories.dart
    └── categories.drift.dart

```

--------------------------------

### PostgreSQL Database Setup with Drift

Source: https://drift.simonbinder.eu/setup

Use this snippet to connect Drift to a PostgreSQL database. It defines the same TodoItems table and uses PgDatabase with pg.Endpoint for connection. Replace the placeholder credentials with your actual database details.

```dart
import 'package:drift/drift.dart';
import 'package:drift_postgres/drift_postgres.dart';
import 'package:postgres/postgres.dart' as pg;

part 'database.g.dart';

class TodoItems extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get title => text().withLength(min: 6, max: 32)();
  TextColumn get content => text().named('body')();
  DateTimeColumn get createdAt => dateTime().nullable()();
}

@DriftDatabase(tables: [TodoItems])
class AppDatabase extends _$AppDatabase {
  // After generating code, this class needs to define a `schemaVersion` getter
  // and a constructor telling drift where the database should be stored.
  // These are described in the getting started guide: https://drift.simonbinder.eu/setup/
  AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());

  @override
  int get schemaVersion => 1;

  static QueryExecutor _openConnection() {
    return PgDatabase(
      endpoint: pg.Endpoint(
        host: 'localhost',
        database: 'database',
        username: 'dart',
        password: 'mysecurepassword',
      ),
    );
  }
}

```

--------------------------------

### Set up in-memory database with NativeDatabase.memory()

Source: https://drift.simonbinder.eu/testing

Creates an in-memory database using NativeDatabase.memory() in setUp and closes it in tearDown. Passes closeStreamsSynchronously: true to avoid test errors in Flutter widget tests.

```dart
import 'package:drift/drift.dart';
import 'package:drift/native.dart';
import 'package:test/test.dart';
// the file defined above, you can test any drift database of course
import 'database.dart';

void main() {
  late AppDatabase database;

  setUp(() {
    database = AppDatabase(
      DatabaseConnection(
        NativeDatabase.memory(),
        // Recommended for widget tests to avoid test errors.
        closeStreamsSynchronously: true,
      ),
    );
  });
  tearDown(() async {
    await database.close();
  });
}
```

--------------------------------

### Open drift database and run insert and select

Source: https://drift.simonbinder.eu/setup

Use this snippet to open the drift database and perform a basic insert and select operation. It requires the generated AppDatabase class and TodoItemsCompanion. The example prints the selected items to the console.

```dart
void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  final database = AppDatabase();

  await database
      .into(database.todoItems)
      .insert(
        TodoItemsCompanion.insert(
          title: 'todo: finish drift setup',
          content: 'We can now write queries and define our own tables.',
        ),
      );
  List<TodoItem> allItems = await database.select(database.todoItems).get();

  print('items in database: $allItems');
}

```

--------------------------------

### Insert data on first app start with MigrationStrategy

Source: https://drift.simonbinder.eu/faq

Use this custom migration strategy to insert data when the database is first created. You can also use transactions or batches inside the onCreate callback.

```dart
MigrationStrategy(
  onCreate: (m) async {
    await m.createAll(); // create all tables
    await into(myTable).insert(...); // insert on first run.
  }
)
```

--------------------------------

### Custom select with variables

Source: https://drift.simonbinder.eu/sql_api/custom_queries

Shows how to bind SQL variables using question-mark placeholders and the variables parameter. The example counts todos in a category and returns a stream of the count.

```dart
Stream<int> amountOfTodosInCategory(int id) {
  return customSelect(
    'SELECT COUNT(*) AS c FROM todo_items WHERE category = ?',
    variables: [Variable.withInt(id)],
    readsFrom: {todoItems},
  ).map((row) => row.read<int>('c')).watchSingle();
}

```

--------------------------------

### Table definitions for nested results example

Source: https://drift.simonbinder.eu/sql_api/drift_files

Defines the `coordinates` and `saved_routes` tables used in the nested results examples. The `saved_routes` table references `coordinates` for `from` and `to`.

```sql
CREATE TABLE coordinates (
  id INTEGER NOT NULL PRIMARY KEY,
  lat REAL NOT NULL,
  long REAL NOT NULL
);

CREATE TABLE saved_routes (
  id INTEGER NOT NULL PRIMARY KEY,
  name TEXT NOT NULL,
  "from" INTEGER NOT NULL REFERENCES coordinates (id),
  "to" INTEGER NOT NULL REFERENCES coordinates (id)
);

```

--------------------------------

### Set up drift_libsql database with synchronization

Source: https://drift.simonbinder.eu/platforms/libsql

Use DriftLibsqlDatabase to connect to a libSQL server while keeping a local replica in sync. Requires the drift_libsql package and a sync URL, auth token, and optional readYourWrites and syncIntervalSeconds settings.

```dart
import 'package:drift/drift.dart';
import 'package:drift_libsql/drift_libsql.dart';

@DriftDatabase(...)
class AppDatabase extends _$AppDatabase {
  AppDatabase(super.e);

  @override
  int get schemaVersion => 1;
}

void main() async {
  final database = AppDatabase(DriftLibsqlDatabase(
    "${dir.path}/replica.db",
    syncUrl: 'hrana url',
    authToken: 'your-token',
    readYourWrites: true,
    syncIntervalSeconds: 3,
  ));
}
```

--------------------------------

### Generate step-by-step migration helper with drift_dev schema steps

Source: https://drift.simonbinder.eu/migrations/step_by_step

Generates the step-by-step migration helper file. The first argument is the folder storing exported schemas, the second is the path of the file to generate. Typically, you'd generate a file next to your database class.

```bash
$ dart run drift_dev schema steps drift_schemas/ lib/database/schema_versions.dart
```

--------------------------------

### Assert cipher availability in NativeDatabase setup

Source: https://drift.simonbinder.eu/platforms/encryption

Adds an assert(_debugCheckHasCipher(database)) before using the database, placed in the setup parameter of a NativeDatabase. This verifies the encrypted variant is available before setting the key.

```dart
NativeDatabase.createInBackground(
  myDatabaseFile,
  setup: (rawDb) {
    assert(_debugCheckHasCipher(rawDb));
    rawDb.execute("PRAGMA key = 'passphrase';");
  },
);

```

--------------------------------

### Update pubspec dependencies for drift

Source: https://drift.simonbinder.eu/guides/upgrading

Replace the moor dependency with drift and moor_generator with drift_dev. If you've been using moor_flutter, also add a dependency on drift_sqflite: ^1.0.0. Run pub get to get the new packages.

```yaml
dependencies:
  drift: ^2.35.0
dev_dependencies:
  drift_dev: ^2.35.0
```

--------------------------------

### GetX: Add database as a service with Get.put

Source: https://drift.simonbinder.eu/faq

Uses the GetX package to manage the database instance. The database is put into GetX's service locator. Widgets access it via Get.find<MyDatabase>().your_method.

```dart
void main() {
  Get.put(MyDatabase());
  runApp(MyFlutterApp());
}
```

--------------------------------

### Generate initial schema with make-migrations

Source: https://drift.simonbinder.eu/migrations

Run this command before making schema changes to generate the initial schema file. Run it again after bumping schemaVersion to generate migration and test files.

```bash
dart run drift_dev make-migrations
```

--------------------------------

### Invalid isolate usage example

Source: https://drift.simonbinder.eu/isolates

Shows an attempt to send a drift database instance across isolates, which fails because drift databases contain references to async primitives that can't be serialized. This example is used to illustrate the limitation that motivates using drift's isolate APIs.

```dart
Future<void> invalidIsolateUsage() async {
  final database = MyDatabase(NativeDatabase.memory());

  // Unfortunately, this doesn't work: Drift databases contain references to
  // async primitives like streams and futures that can't be serialized across
  // isolates like this.
  await Isolate.run(() async {
    await database.batch((batch) {
      // ...
    });
  });
}

```

--------------------------------

### Use custom type in SQL with inline Dart syntax

Source: https://drift.simonbinder.eu/sql_api/types

Uses Drift's inline Dart syntax in a SQL file to define a custom type for a column. The example imports the Dart file containing the custom type and applies it to the frequency column. Note that custom types in drift files have limited support, for example they are not supported in CAST expressions.

```sql
import 'type.dart';

CREATE TABLE periodic_reminders (
  id INTEGER NOT NULL PRIMARY KEY,
  frequency `const DurationType()` NOT NULL,
  reminder TEXT NOT NULL
);

```

--------------------------------

### Using LazyDatabase for async database loading

Source: https://drift.simonbinder.eu/platforms/vm

Shows how to switch from directly opening a file with NativeDatabase to using LazyDatabase for async initialization, such as copying from assets or network before opening.

```dart
// before
NativeDatabase(File('...'));

// after
LazyDatabase(() async {
  final file = File('...');
  if (!await file.exists()) {
    // copy the file from an asset, or network, or any other source
  }
  return NativeDatabase(file);
});
```

--------------------------------

### Dart query builder example

Source: https://drift.simonbinder.eu/guides/migrating_to_drift

The same query written using the drift query builder in Dart, returning a stream.

```dart
Stream<List<TestData>> queryWithDartCode() {
  final query = select(test)..where((row) => row.value.isBiggerThanValue(12));
  return query.watch();
}

```

--------------------------------

### JSON output with custom JSON key

Source: https://drift.simonbinder.eu/dart_api/rows

Example JSON output when the createdAt column uses a custom JSON key 'created'.

```json
{
  "id": 1,
  "title": "Todo 1",
  "created": "2024-02-29T12:00:00Z"
}

```

--------------------------------

### Manually open drift database with LazyDatabase

Source: https://drift.simonbinder.eu/setup

Manual database setup using LazyDatabase and NativeDatabase.createInBackground. Stores the database file in the documents folder, sets sqlite3.tempDirectory to the temporary directory to avoid Android sandboxing issues, and is used when you need to customize how databases are opened.

```dart
import 'dart:io';
import 'package:drift/native.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as p;
import 'package:sqlite3/sqlite3.dart';

LazyDatabase openConnection() {
  // the LazyDatabase util lets us find the right location for the file async.
  return LazyDatabase(() async {
    // put the database file, called db.sqlite here, into the documents folder
    // for your app.
    final dbFolder = await getApplicationDocumentsDirectory();
    final file = File(p.join(dbFolder.path, 'db.sqlite'));

    // Make sqlite3 pick a more suitable location for temporary files - the
    // one from the system may be inaccessible due to sandboxing.
    final cachebase = (await getTemporaryDirectory()).path;
    // We can't access /tmp on Android, which sqlite3 would try by default.
    // Explicitly tell it about the correct temporary directory.
    sqlite3.tempDirectory = cachebase;

    return NativeDatabase.createInBackground(file);
  });
}

```

--------------------------------

### JSON output for a Dart-defined table

Source: https://drift.simonbinder.eu/dart_api/rows

Example JSON output for a Todos row, showing the default JSON keys derived from the Dart getter names.

```json
{
  "id": 1,
  "title": "Todo 1",
  "createdAt": "2024-02-29T12:00:00Z"
}

```

--------------------------------

### Simple query for a single table

Source: https://drift.simonbinder.eu/dart_api/schema_inspection

A straightforward query that filters rows by their 'id' column on a specific table, 'todos'. This is the baseline example before generalizing to any table.

```dart
Selectable<Todo> findTodoEntryById(int id) {
  return select(todos)..where((row) => row.id.equals(id));
}

```

--------------------------------

### Set up a drift web worker with driftWorkerMain

Source: https://drift.simonbinder.eu/platforms/web

Create a web worker file (e.g., worker.dart) to serve drift requests in a background thread. This legacy API uses DriftWebStorage.indexedDb with inWebWorker: true and loads sql.js via importScripts. Note that this is a legacy API; consider migrating to package:drift/wasm.dart which has builtin web worker support.

```dart
// Note: This snippet describes a legacy API! Please consider migrating to
// `package:drift/wasm.dart`, which has builtin support for web workers!
import 'dart:html'; // ignore: deprecated_member_use

import 'package:drift/drift.dart';
import 'package:drift/web.dart'; // ignore: deprecated_member_use
import 'package:drift/web/worker.dart'; // ignore: deprecated_member_use

void main() {
  // Load sql.js library in the worker
  WorkerGlobalScope.instance.importScripts('sql-wasm.js');

  // Call drift function that will set up this worker
  driftWorkerMain(() {
    return WebDatabase.withStorage(
      DriftWebStorage.indexedDb(
        'worker',
        migrateFromLocalStorage: false,
        inWebWorker: true,
      ),
    );
  });
}
```

--------------------------------

### Enforce a composite unique key with uniqueKeys

Source: https://drift.simonbinder.eu/dart_api/tables

Overrides the `uniqueKeys` getter to enforce that a combination of columns is unique. The example ensures the same room cannot be reserved twice on the same day.

```dart
class Reservations extends Table {
  late final reservationId = integer().autoIncrement()();

  late final room = text()();
  late final onDay = dateTime()();

  @override
  List<Set<Column>> get uniqueKeys => [
    {room, onDay},
  ];
}

```

--------------------------------

### Migrate custom WasmDatabase to WasmDatabase.open

Source: https://drift.simonbinder.eu/platforms/web

Migrates a custom WasmDatabase setup that manually loaded sqlite3 and used IndexedDbFileSystem to the stable WasmDatabase.open API. The initializeDatabase callback copies the old database file from the IndexedDB file system and returns it as Uint8List so WasmDatabase.open can use it.

```dart
// If you've previously opened your database like this
Future<WasmDatabase> customDatabase() async {
  final sqlite3 = await WasmSqlite3.loadFromUrl(Uri.parse('/sqlite3.wasm'));
  final fs = await IndexedDbFileSystem.open(dbName: 'my_app');
  sqlite3.registerVirtualFileSystem(fs, makeDefault: true);

  return WasmDatabase(sqlite3: sqlite3, path: '/app.db');
}
// Then you can migrate like this
final result = await WasmDatabase.open(
  databaseName: 'my_app',
  sqlite3Uri: Uri.parse('sqlite3.wasm'),
  driftWorkerUri: Uri.parse('drift_worker.dart.js'),
  initializeDatabase: () async {
    // Manually open the file system previously used
    final fs = await IndexedDbFileSystem.open(dbName: 'my_app');
    const oldPath = '/app.db'; // The path passed to WasmDatabase before

    Uint8List? oldDatabase;

    // Check if the old database exists
    if (fs.xAccess(oldPath, 0) != 0) {
      // It does, then copy the old file
      final (file: file, outFlags: _) = fs.xOpen(
        Sqlite3Filename(oldPath),
        0,
      );
      final blob = Uint8List(file.xFileSize());
      file.xRead(blob, 0);
      file.xClose();
      fs.xDelete(oldPath, 0);

      oldDatabase = blob;
    }

    await fs.close();
    return oldDatabase;
  },
);

```

--------------------------------

### Use custom reference names in queries

Source: https://drift.simonbinder.eu/dart_api/manager

Use the custom reference names defined with @ReferenceName in filters. This example filters users based on administered or owned groups.

```dart
Future<void> reverseNamedRelationalFilter() async {
  // Get all users who are administrators of a group with a name containing "Business"
  // or who own a group with an id of 1, 2, 4, or 5
  managers.users.filter(
    (f) =>
        f.administeredGroups((f) => f.name.contains("Business")) |
        f.ownedGroups((f) => f.id.isIn([1, 2, 4, 5])),
  );
}

```

--------------------------------

### Using RowValues in a query

Source: https://drift.simonbinder.eu/dart_api/expressions

Use the custom RowValues expression in a query. This example shows how to compare row values in a where clause, generating SQL like (amount_of_legs, average_livespan) < (?, ?).

```dart
void rowValuesUsage() {
  select(animals).where((row) {
    // Generates (amount_of_legs, average_livespan) < (?, ?)
    return RowValues([
      row.amountOfLegs,
      row.averageLivespan,
    ]).isSmallerThan(RowValues([Variable(2), Variable(10)]));
  });
}
```

--------------------------------

### Configure databases in build.yaml for make-migrations

Source: https://drift.simonbinder.eu/migrations

Configure the drift_dev builder in build.yaml to specify the database files that make-migrations should track. The databases key is required and maps a name to the Dart file containing the database class.

```yaml
targets:
  $default:
    builders:
      drift_dev:
        options:
          databases:
            # Required: A name for the database and its path
            my_database: lib/database.dart

            # Optional: Add more databases
            another_db: lib/database2.dart
```

--------------------------------

### Pin `from` value in `Migrator.runMigrationSteps` to move to step-by-step migrations

Source: https://drift.simonbinder.eu/migrations/step_by_step

Use this onUpgrade callback to transition to step-by-step migrations by pinning the `from` value to a known starting point. It manually runs migrations up to schema version 2, then uses `runMigrationSteps` with a floor of 2, and includes foreign key checks in debug mode.

```dart
onUpgrade: (m, from, to) async {
  // Run migration steps without foreign keys and re-enable them later
  // (https://drift.simonbinder.eu/docs/advanced-features/migrations/#tips)
  await customStatement('PRAGMA foreign_keys = OFF');

  // Manually running migrations up to schema version 2, after which we've
  // enabled step-by-step migrations.
  if (from < 2) {
    // we added the dueDate property in the change from version 1 to
    // version 2 - before switching to step-by-step migrations.
    await m.addColumn(todos, todos.dueDate);
  }

  // At this point, we should be migrated to schema 3. For future schema
  // changes, we will "start" at schema 3.
  await m.runMigrationSteps(
    from: math.max(2, from),
    to: to,
    steps: migrationSteps(
            from2To3: (m, schema) async {
              // we added the priority property in the change from version 1 or
              // 2 to version 3
              await m.addColumn(schema.todos, schema.todos.priority);
            },
          ),
        );

        if (kDebugMode) {
          // Fail if the migration broke foreign keys
          final wrongForeignKeys = await customSelect(
            'PRAGMA foreign_key_check',
          ).get();
          assert(
            wrongForeignKeys.isEmpty,
            '${wrongForeignKeys.map((e) => e.data)}',
          );
        }

        await customStatement('PRAGMA foreign_keys = ON;');
      },
```

--------------------------------

### Web database constructor (web.dart)

Source: https://drift.simonbinder.eu/platforms/web

Create a web database instance using WasmDatabase.open with a delayed connection. This file is used for web support and is part of the conditional export setup.

```dart
// web.dart
import 'package:drift/wasm.dart';

SharedDatabase constructDb() {
  return SharedDatabase(connectOnWeb());
}

DatabaseConnection connectOnWeb() {
  return DatabaseConnection.delayed(Future(() async {
    final result = await WasmDatabase.open(
      databaseName: 'my_app_db', // prefer to only use valid identifiers here
      sqlite3Uri: Uri.parse('sqlite3.wasm'),
      driftWorkerUri: Uri.parse('drift_worker.dart.js'),
    );

    if (result.missingFeatures.isNotEmpty) {
      // Depending how central local persistence is to your app, you may want
      // to show a warning to the user if only unrealiable implemetentations
      // are available.
      print('Using ${result.chosenImplementation} due to missing browser '
          'features: ${result.missingFeatures}');
    }

    return result.resolvedExecutor;
  }));
}
```

--------------------------------

### Native database constructor (native.dart)

Source: https://drift.simonbinder.eu/platforms/web

Create a native database instance using LazyDatabase and NativeDatabase. This file is used for native Flutter apps and is part of the conditional export setup.

```dart
// native.dart
import 'package:drift/native.dart';

SharedDatabase constructDb() {
  final db = LazyDatabase(() async {
    final dbFolder = await getApplicationDocumentsDirectory();
    final file = File(p.join(dbFolder.path, 'db.sqlite'));
    return NativeDatabase(file);
  });
  return SharedDatabase(db);
}
```

--------------------------------

### Set up drift_hrana database for server-only queries

Source: https://drift.simonbinder.eu/platforms/libsql

Use HranaDatabase to connect to a hosted libSQL server via the Hrana protocol, running all queries against the server without local caching. Requires the drift_hrana package and a WebSocket URI; note that streamed queries across different clients are not supported.

```dart
import 'package:drift/drift.dart';
import 'package:drift_hrana/drift_hrana.dart';

@DriftDatabase(...)
class AppDatabase extends _$AppDatabase {
  AppDatabase(super.e);

  @override
  int get schemaVersion => 1;
}

void main() async {
  final database = AppDatabase(HranaDatabase(
    Uri.parse('ws://localhost:8080/'),
    jwtToken: null,
  ));
}
```

--------------------------------

### Use generated query method

Source: https://drift.simonbinder.eu/sql_api/custom_queries

Use the generated categoriesWithCount() method to run the query once with get() or watch() for an auto-updating stream. The stream emits snapshots with the number of category results.

```dart
Future<void> useGeneratedQuery() async {
  // The generated query can be run once as a future:
  await categoriesWithCount().get();

  // Or multiple times as a stream
  await for (final snapshot in categoriesWithCount().watch()) {
    print('Found ${snapshot.length} category results');
  }
}
```

--------------------------------

### Define initial drift database class with TodoItems table

Source: https://drift.simonbinder.eu/setup

Initial database.dart file with a TodoItems table and an AppDatabase class annotated with @DriftDatabase. Expect analyzer warnings on the part statement and extends _$AppDatabase until the generator runs.

```dart
import 'package:drift/drift.dart';

part 'database.g.dart';

class TodoItems extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get title => text().withLength(min: 6, max: 32)();
  TextColumn get content => text().named('body')();
  DateTimeColumn get createdAt => dateTime().nullable()();
}

@DriftDatabase(tables: [TodoItems])
class AppDatabase extends _$AppDatabase {
}

```

--------------------------------

### Create route_points table for LIST() subquery

Source: https://drift.simonbinder.eu/sql_api/drift_files

Defines a junction table that stores coordinates along a route, referencing the saved_routes and coordinates tables. This table is used in the LIST() subquery example.

```sql
CREATE TABLE route_points (
  route INTEGER NOT NULL REFERENCES saved_routes (id),
  point INTEGER NOT NULL REFERENCES coordinates (id),
  index_on_route INTEGER,
  PRIMARY KEY (route, point)
);

```

--------------------------------

### Project structure before modular generation

Source: https://drift.simonbinder.eu/generation_options/modular

Shows the source file structure of a large drift project before modular generation, with tables and views split across multiple files.

```text
lib/src/database/
├── database.dart
├── tables/
│   ├── users.drift
│   ├── settings.drift
│   ├── groups.drift
│   └── search.drift
└── views/
    ├── friends.drift
    └── categories.dart

```

--------------------------------

### Open existing database with initializeDatabase

Source: https://drift.simonbinder.eu/platforms/web

Open an existing database on the web by providing an initializeDatabase callback to WasmDatabase.open. The callback loads the initial sqlite3 file from the app bundle and returns its bytes.

```dart
return DatabaseConnection.delayed(
  Future(() async {
    final result = await WasmDatabase.open(
      databaseName: 'my_app_db', // prefer to only use valid identifiers here
      sqlite3Uri: Uri.parse('sqlite3.wasm'),
      driftWorkerUri: Uri.parse('drift_worker.dart.js'),
      initializeDatabase: () async {
        final data = await rootBundle.load('my_database');
        return data.buffer.asUint8List();
      },
    );

    // ...
    return result.resolvedExecutor;
  }),
);
```
Tokens:
Raw