Drift (Moor) — ce este, ORM reactiv și lucrul cu baze de date

Ce este Drift?

Drift — ORM pentru Dart și Flutter, cunoscut anterior ca Moor. A fost dezvoltat de Simon Binder în 2019 și de atunci a trecut prin mai multe versiuni majore. Drift compilează interogările Dart în SQL în etapa de build folosind drift_dev și build_runner, oferind siguranță completă a tipurilor și eliminând erorile de sintaxă SQL în runtime.

Spre deosebire de Floor, Drift folosește propriul DSL (Domain-Specific Language) pentru construirea interogărilor — dezvoltatorul scrie în Dart, iar generatorul traduce acest lucru în SQL. Acest lucru permite IDE-ului să verifice sintaxa, să completeze automat câmpurile tabelelor și să refactorizeze modelul de date fără teama de a strica interogarea.

Potrivit Drift (2024), biblioteca este folosită în peste 8000 de proiecte Flutter. Acceptă toate platformele populare: Android prin sqflite, iOS prin sqflite, web prin sqlite3 WASM, desktop prin driverul nativ sqlite3.

Istoria redenumirii: Moor → Drift

Moor a fost redenumit în Drift în versiunea 2.0 (2022). Motivul — conflictul de nume cu alte proiecte și dorința de a se distanța de codul vechi. API-ul a rămas compatibil: pentru migrare este suficient să înlocuiți importul din moor cu drift și să actualizați dependențele.

Capabilități cheie

Drift oferă: interogări Stream încorporate cu actualizare automată la modificarea datelor, suport pentru tranzacții cu revenire, interogări SQL personalizate prin rawQuery, modelul DAO pentru încapsularea logicii, migrări cross-platform și integrare cu Riverpod și BLoC prin pachetele drift_riverpod și drift_bloc.

Cum funcționează Drift?

Drift utilizează generarea de cod în etapa de compilare. Dezvoltatorul descrie tabelele prin adnotări @DataClass sau clase Dart care extind Table. Generatorul creează clase ajutătoare: Companion (pentru câmpurile nullable la inserare/actualizare), DriftDatabase (punctul de intrare) și implementări DAO.

Interogările SQLite nu sunt executate direct de Drift. În schimb, dezvoltatorul scrie în Dart: select(tasks).where(tasks.priority.greaterThan(3)).build(). Generatorul traduce aceasta în SQL, iar în timpul execuției Drift trimite pur și simplu interogarea SQL pregătită către SQLite. Aceasta combină comoditatea sintaxei Dart cu performanța SQL-ului nativ.

Arhitectura interogărilor

Drift suportă două moduri de interogare: DSL (recomandat) și raw SQL. Interogările DSL sunt mai sigure — compilatorul verifică numele câmpurilor, tipurile și compatibilitatea. Raw SQL este necesar pentru interogări complexe neacoperite de DSL: funcții fereastră, CTE recursive, extensii specifice SQLite.

Drift DSL vs SQL: compararea abordărilor

Drift oferă două moduri de a scrie interogări: Dart DSL (nativ) și raw SQL (pentru cazuri complexe). DSL este preferat în 90% din scenarii: este mai sigur, mai lizibil și suportă refactorizarea. Raw SQL este folosit doar atunci când DSL nu acoperă construcția necesară.

Când să folosiți DSL

Drift DSL — modul principal de lucru. Acoperă SELECT, INSERT, UPDATE, DELETE, WHERE, ORDER BY, LIMIT, JOIN și grupare. Pentru toate interogările CRUD tipice, folosiți DSL: este mai scurt, mai sigur și actualizează automat Stream-ul la modificări.

Când să folosiți raw SQL

Raw SQL în Drift este necesar pentru: funcții SQLite personalizate (FTS5, JSON1), subinterogări complexe cu EXISTS, INSERT OR REPLACE, UPDATE-uri în masă cu CASE, precum și pentru interogări unde performanța este critică și DSL nu generează un plan de execuție optim. Raw SQL poate fi scris în fișiere .sql cu suport de tipizare prin drift_dev.

Exemple de cod cu Drift

Drift folosește clase care extind Table sau adnotarea @DataClass. Mai jos — un exemplu complet al modelului Task cu interogări prin DSL, raw SQL și actualizare reactivă. După rularea build_runner, toate clasele generate sunt gata.

Definirea tabelului și a bazei de date

Clasa Tasks extinde Table și definește coloanele. Fiecare coloană este o expresie de tip Column<T>. Parametrii: withDefault() setează valoarea implicită, autoIncrement() asigură auto-incrementarea. Baza de date este o clasă abstractă care extinde $DriftDatabase.

class Tasks extends Table {
    IntColumn get id => integer().autoIncrement();
    TextColumn get title => text().withDefault(const Constant(''))();
    BoolColumn get isCompleted => boolean().withDefault(const Constant(false))();
    IntColumn get priority => integer().withDefault(const Constant(0))();
}

@DriftDatabase(tables: [Tasks])
class AppDatabase extends $AppDatabase {
    AppDatabase(QueryExecutor e) : super(e);
}

Operații CRUD prin DSL

Drift generează metodele into(tasks).insert(), select(tasks), update(tasks) și delete(tasks) pentru tabele. Toate operațiile returnează Future — lucrul cu SQLite este asincron. Pentru urmărirea modificărilor, folosiți .watch() în loc de .get().

// Înregistrare
await into(tasks).insert(TasksCompanion.insert(
    title: Value('Cumpără produse'),
    priority: Value(3),
));

// Citire cu filtru
final highPriority = await (select(tasks)
    ..where((t) => t.priority.greaterThan(2))
    ..orderBy([(t) => OrderingTerm(expression: t.priority, mode: OrderingMode.desc)]))
    .get();

// Observare reactivă
select(tasks).watch().listen((tasksList) {
    // tasksList — List, se actualizează la fiecare modificare a tabelului
    updateUi(tasksList);
});

Raw SQL cu rezultat tipizat

Pentru interogări complexe, Drift permite scrierea raw SQL, păstrând în același timp tipizarea. Metoda customSelect primește un șir de interogare și returnează un rezultat tipizat prin generatorul de cod. Această abordare combină flexibilitatea SQL cu siguranța tipurilor Drift.

final result = await customSelect(
    'SELECT title, COUNT(*) as cnt FROM tasks GROUP BY title',
    readsFrom: { tasks },
).get();

for (final row in result) {
    print('${row.readString("title")}: ${row.readInt("cnt")}');
}

Migrări și versionare în Drift

Drift suportă atât migrări automate (pentru modificări simple), cât și manuale (pentru transformări complexe). Versiunea bazei de date se setează în constructorul AppDatabase. La nepotrivirea versiunii, Drift aplică toate migrările neînchise secvențial.

Migrări automate

Pentru adăugarea unei coloane cu valoare implicită, Drift poate genera automat o migrare prin MigrationStrategy. Dacă modificarea nu încalcă datele existente (adăugarea unui câmp nullable), se poate folosi beforeOpen cu verificarea versiunii și executarea ALTER TABLE.

Migrări manuale

Pentru modificări complexe (redenumirea tabelului, îmbinarea datelor, schimbarea tipului coloanei), Drift necesită migrare SQL manuală. Migrările se specifică prin parametrul migrations în clasa bazei de date. Fiecare migrare este un obiect cu numerele from/to și interogări SQL.

Drift și testarea

Drift suportă rularea în modul de test prin NativeDatabase.memory(). Baza de date în memorie este creată de la zero înainte de fiecare test și distrusă după. Pentru mock, folosiți pachetul mocktail cu un QueryExecutor simulat. Drift oferă, de asemenea, DatabaseTestHelper pentru teste de integrare cu verificarea migrărilor și interogărilor.

Modelul DAO în Drift

Drift suportă DAO (Data Access Object) prin clase abstracte cu adnotarea @DriftAccessor. DAO încapsulează interogările către una sau mai multe tabele și poate fi testat separat de baza de date. Spre deosebire de interogările directe prin Database, DAO permite reutilizarea logicii interogărilor între diferite părți ale aplicației și simplifică testarea modulară.

@DriftDatabase(tables: [Tasks])
class AppDatabase extends $AppDatabase {
    AppDatabase(QueryExecutor e) : super(e) {
        migrations.add(Migration(1, 2, (m) async {
            await m.addColumn(tasks, tasks.dueDate);
            await m.createIndex(tasks.idxPriority);
        }));
    }
}