Comment utiliser SQLite dans Flutter

Créer une classe modèle (model class)

• Une classe modèle représente une ligne d'une table : chaque attribut de la classe correspond à une colonne de la table. Elle sert d'intermédiaire entre vos objets Dart et la base.
• Pour créer une classe modèle :
  1. identifier les colonnes de la table et leur type ;
  2. créer la classe avec un attribut par colonne et un constructeur ;
  3. ajouter toMap() pour transformer un objet en Map avant de l'enregistrer ;
  4. ajouter fromMap() pour recréer un objet à partir d'une ligne lue dans la base.
• Pourquoi des Map? Parce que sqflite ne connaît pas vos classes : il reçoit et renvoie chaque ligne sous la forme d'une Map<String, dynamic> dont les clés sont les noms des colonnes.

• 6.1. La méthode toMap(): de l'objet vers la base

  • Elle convertit l'objet en Map: chaque attribut devient une paire nom de colonne → valeur. C'est cette Map que l'on passe à db.insert() ou db.update().

• 6.2. Le constructeur fromMap(): de la base vers l'objet

  • Il fait l'inverse : il lit les valeurs de la Map renvoyée par db.query() et crée un objet. On l'écrit en général avec un constructeur factory (voir la leçon Comprendre le concept du mot-clé « factory »).

• 6.3. Exemple complet : la classe Person

class Person {
  final int? id;      // null tant que la personne n'est pas enregistrée (AUTOINCREMENT)
  final String name;  // colonne name
  final int age;      // colonne age
  const Person({this.id, required this.name, required this.age});
  // Objet -> Map : utilisé pour insert() et update()
  Map<String, dynamic> toMap() {
    return {
      if (id != null) 'id': id,   // on laisse SQLite générer l'id d'une nouvelle personne
      'name': name,
      'age': age,
    };
  }
  // Map -> objet : utilisé après query()
  factory Person.fromMap(Map<String, dynamic> map) {
    return Person(
      id: map['id'] as int?,
      name: map['name'] as String,
      age: map['age'] as int,
    );
  }
  @override
  String toString() => 'Person(id: $id, name: $name, age: $age)';
}
void main() {
  const person = Person(name: 'John', age: 30);
  final personMap = person.toMap();
  print('Person as Map: $personMap');          // {name: John, age: 30}
  final copie = Person.fromMap({'id': 1, 'name': 'John', 'age': 30});
  print('Person from Map: $copie');            // Person(id: 1, name: John, age: 30)
}

• 6.4. Le type dynamic dans Map<String, dynamic>

  • Les clés sont toujours des String (les noms des colonnes), mais les valeurs ont des types différents d'une colonne à l'autre : texte, entier, décimal… dynamic permet de les ranger dans la même Map.
  • Exemple :

Map<String, dynamic> person = {
  'name': 'John Doe',     // String
  'age': 30,              // int
  'isEmployed': true,     // bool
  'height': 1.82,         // double
  'favorites': ['pizza', 'movies', 'coding'],  // List<String>
};

• 6.5. Les types que SQLite ne connaît pas

  • SQLite ne stocke que des entiers (INTEGER), des décimaux (REAL), du texte (TEXT) et des données binaires (BLOB). Les autres types Dart doivent être convertis dans toMap() et fromMap():

• Activité 01 : écrire toMap()

  • Soit le constructeur fromMap suivant :

factory Book.fromMap(Map map) {
  return Book(
    title: map['title'],
    author: map['author'],
    pageCount: map['pageCount'],
  );
}

• Créer la classe modèle Book avec les attributs nécessaires et leur type.
• Écrire la méthode toMap() correspondante.
• Améliorer ce fromMap: préciser le type de la Map (Map<String, dynamic>) et convertir chaque valeur avec as. Expliquer en une phrase ce que l'on gagne.

• Activité 02 : la classe Product

  1. Définir une classe modèle Product avec les attributs id (int?), name (String), price (double) et description (String?).
  2. Écrire un constructeur avec des paramètres nommés.
  3. Écrire toMap() et le constructeur factory Product.fromMap(), en convertissant correctement le prix.
  4. Dans main(), créer deux produits, les convertir en Map, les recréer avec fromMap() et afficher le résultat.

• Activité 03 : gérer un bool et une date

  1. Créer une classe Tache avec les attributs id (int?), titre (String), terminee (bool) et echeance (DateTime).
  2. Écrire toMap() et fromMap() en appliquant les conversions du tableau 6.5.
  3. Dans DB Browser, écrire le CREATE TABLE taches correspondant, insérer deux tâches à la main et vérifier comment sont stockées les colonnes terminee et echeance.

• 6.6. Un autre exemple : la classe Movie

  • Pour une table movies (identifiant, titre, année, langue), la classe modèle s'écrit sur le même principe :

class Movie {
  final int? id;          // colonne id INTEGER PRIMARY KEY AUTOINCREMENT
  final String title;     // colonne title TEXT
  final int year;         // colonne year INTEGER
  final String language;  // colonne language TEXT
  const Movie({this.id, required this.title, required this.year, required this.language});
  Map<String, dynamic> toMap() => {
        if (id != null) 'id': id,
        'title': title,
        'year': year,
        'language': language,
      };
  factory Movie.fromMap(Map<String, dynamic> map) => Movie(
        id: map['id'] as int?,
        title: map['title'] as String,
        year: map['year'] as int,
        language: map['language'] as String,
      );
}

7. Créer la base de données et les tables

   • Pour utiliser SQLite, il faut ouvrir le fichier de la base avec openDatabase(). S'il n'existe pas encore, il est créé et la fonction onCreate est appelée pour créer les tables. On regroupe tout ce code dans une classe unique, DatabaseService, rangée dans lib/services/database_service.dart.

   • 7.1. Une seule instance : le patron Singleton

     • Un Singleton est une classe qui n'a qu'une seule instance dans toute l'application : chaque appel à DatabaseService() renvoie le même objet, donc la même connexion à la base.
     • Ce n'est pas obligatoire, mais c'est la bonne pratique pour une base de données :
       • gestion centralisée : tout le code d'accès à la base est au même endroit ;
       • pas de connexions multiples : la base n'est ouverte qu'une fois, ce qui évite les conflits et le gaspillage de ressources ;
       • maintenance facilitée : une modification de la base n'a qu'un seul point d'impact.

// L'unique instance, créée une seule fois
static final DatabaseService _instance = DatabaseService._internal();
// Constructeur factory : DatabaseService() renvoie toujours _instance
factory DatabaseService() => _instance;
// Constructeur privé : impossible de créer une autre instance depuis l'extérieur
DatabaseService._internal();
// La connexion à la base, créée au premier besoin
static Database? _database;

• 7.2. Ouvrir la base au premier besoin

  • Le getter database ouvre la base au premier appel, puis renvoie toujours la même connexion. Il renvoie une Future, car l'ouverture d'un fichier prend du temps et ne doit pas bloquer l'affichage (voir Les fonctions asynchrones en Dart).

Future<Database> get database async {
  _database ??= await _initDatabase();   // ouvre la base seulement si elle ne l'est pas déjà
  return _database!;
}
Future<Database> _initDatabase() async {
  // Dossier prévu par le système pour les bases de l'application
  final path = join(await getDatabasesPath(), 'people.db');
  debugPrint('Base SQLite : $path');
  return openDatabase(
    path,
    version: 1,
    onCreate: _createTables,
  );
}

• 7.3. Les principaux paramètres de openDatabase()

• 7.4. Créer les tables dans onCreate

Future<void> _createTables(Database db, int version) async {
  await db.execute('''
    CREATE TABLE persons (
      id   INTEGER PRIMARY KEY AUTOINCREMENT,
      name TEXT    NOT NULL,
      age  INTEGER NOT NULL
    )
  ''');
  debugPrint('onCreate : table persons créée');
}

• 7.5. Le fichier complet database_service.dart

  • Voici la classe complète pour la table persons, avec les quatre opérations CRUD. Chaque méthode récupère la connexion avec await database, puis utilise toMap() ou fromMap().

import 'package:flutter/foundation.dart';
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';
import '../models/person.dart';
class DatabaseService {
  // ---------- Singleton ----------
  static final DatabaseService _instance = DatabaseService._internal();
  factory DatabaseService() => _instance;
  DatabaseService._internal();
  static Database? _database;
  Future<Database> get database async {
    _database ??= await _initDatabase();
    return _database!;
  }
  // ---------- Ouverture et création ----------
  Future<Database> _initDatabase() async {
    final path = join(await getDatabasesPath(), 'people.db');
    debugPrint('Base SQLite : $path');
    return openDatabase(path, version: 1, onCreate: _createTables);
  }
  Future<void> _createTables(Database db, int version) async {
    await db.execute('''
      CREATE TABLE persons (
        id   INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT    NOT NULL,
        age  INTEGER NOT NULL
      )
    ''');
  }
  // ---------- Create ----------
  Future<int> addPerson(Person person) async {
    final db = await database;
    return db.insert('persons', person.toMap());        // renvoie l'id créé
  }
  // ---------- Read ----------
  Future<List<Person>> getAllPersons() async {
    final db = await database;
    final rows = await db.query('persons', orderBy: 'name');
    return rows.map((row) => Person.fromMap(row)).toList();
  }
  Future<Person?> getPerson(int id) async {
    final db = await database;
    final rows = await db.query('persons', where: 'id = ?', whereArgs: [id], limit: 1);
    return rows.isEmpty ? null : Person.fromMap(rows.first);
  }
  // ---------- Update ----------
  Future<int> updatePerson(Person person) async {
    final db = await database;
    return db.update('persons', person.toMap(),
        where: 'id = ?', whereArgs: [person.id]);        // renvoie le nombre de lignes modifiées
  }
  // ---------- Delete ----------
  Future<int> deletePerson(int id) async {
    final db = await database;
    return db.delete('persons', where: 'id = ?', whereArgs: [id]);
  }
}

8. Utiliser la base depuis main.dart

   • Avant d'utiliser SQLite au démarrage, Flutter doit être initialisé : on appelle WidgetsFlutterBinding.ensureInitialized() au début de main().
   • Le petit programme suivant insère deux personnes, les relit, en modifie une, en supprime une, et affiche le résultat dans la console (Debug Console de VS Code) :

import 'package:flutter/material.dart';
import 'models/person.dart';
import 'services/database_service.dart';
Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final db = DatabaseService();
  // Create
  final idSarra = await db.addPerson(const Person(name: 'Sarra', age: 21));
  await db.addPerson(const Person(name: 'Youssef', age: 25));
  debugPrint('Sarra enregistrée avec l\'id $idSarra');
  // Read
  debugPrint('Toutes les personnes : ${await db.getAllPersons()}');
  // Update
  await db.updatePerson(Person(id: idSarra, name: 'Sarra', age: 22));
  // Delete
  final persons = await db.getAllPersons();
  await db.deletePerson(persons.last.id!);
  debugPrint('Après modification et suppression : ${await db.getAllPersons()}');
  runApp(const MaterialApp(
    home: Scaffold(body: Center(child: Text('Voir la console'))),
  ));
}

9. Vérifier la base de l'application dans DB Browser

   • Le fichier people.db est créé sur l'appareil, au chemin affiché dans la console. Pour l'ouvrir dans DB Browser, il faut d'abord le récupérer sur l'ordinateur :

rem Remplacer com.example.mon_projet par le nom du paquet (applicationId dans android/app/build.gradle.kts)
adb exec-out run-as com.example.mon_projet cat databases/people.db > people.db
adb exec-out run-as com.example.mon_projet cat databases/people.db-wal > people.db-wal

• Dans DB Browser, vérifier :
  • onglet Structure: la table persons et ses trois colonnes, identiques à celles de essai.db (section 4.3) ;
  • onglet Parcourir les données: les lignes insérées par l'application, avec leur id généré automatiquement ;
  • onglet Éditer les pragmas: la ligne User Version vaut 1, la valeur du paramètre version de openDatabase().

10. Erreurs fréquentes et solutions

11. Activité de synthèse : gérer des étudiants

    • Objectif : refaire seul toute la démarche du cours pour une table students.
    • Consignes :
      1. Dans DB Browser : créer une base brouillon.db et y tester le CREATE TABLE students avec les colonnes id (entier, clé primaire auto-incrémentée), name (texte obligatoire), age (entier), major (spécialité, texte), email (texte unique) et actif (booléen stocké en 0/1). Insérer trois étudiants et écrire une requête qui affiche les étudiants actifs triés par nom.
      2. Classe modèle : créer lib/models/student.dart avec la classe Student, son constructeur, toMap(), factory Student.fromMap() et toString().
      3. Service : créer lib/services/database_service.dart sur le modèle de la section 7.5 (Singleton, base school.db, table students) avec les méthodes addStudent, getAllStudents, getStudent, updateStudent et deleteStudent.
      4. Test : dans main.dart, insérer trois étudiants, en modifier un, en supprimer un et afficher la liste dans la console après chaque opération.
      5. Erreur volontaire : insérer deux étudiants avec le même e-mail. Relever le message d'erreur et l'intercepter avec un try / catch qui affiche « Cet e-mail est déjà utilisé ».
      6. Vérification : récupérer school.db et l'ouvrir dans DB Browser. Faire une capture de l'onglet Parcourir les données montrant la table students.