ORM pour Swift (iOS/macOS) : comparaison et exemples d'utilisation

ORM pour Swift (iOS/macOS) : comparaison et exemples

Lors du développement d'applications pour iOS et macOS, les développeurs sont souvent confrontés à la nécessité de stocker des données sur l'appareil. Pour simplifier le travail avec les bases de données, on utilise des ORM (Object-Relational Mapping) — des bibliothèques qui permettent de travailler avec les données comme avec des objets Swift ordinaires, en masquant la complexité des requêtes SQL. Dans cet article, nous examinerons quatre solutions populaires : Core Data, Realm, GRDB et SQLite.swift, nous comparerons leurs fonctionnalités et fournirons des exemples pratiques.

1. Core Data

Core Data est un framework d'Apple, intégré dans iOS et macOS. Ce n'est pas un ORM pur, mais plutôt un framework de gestion de graphe d'objets, qui peut utiliser SQLite, XML ou un stockage binaire.

Avantages :

• Intégration profonde avec l'écosystème Apple (SwiftUI, iCloud, Undo Manager).
• Éditeur visuel de modèle de données (Xcode Data Modeler).
• Prise en charge du versionnement et des migrations.

Inconvénients :

• Courbe d'apprentissage élevée (beaucoup de code boilerplate).
• Problèmes de performance avec de grands ensembles de données.
• Fort couplage aux plateformes Apple.

Exemple de code (Swift) :

import CoreData

// Création du contextelet container = NSPersistentContainer(name: "Model")container.loadPersistentStores { _, error in    if let error = error { print(error) }}

// Sauvegarde de l'objetlet context = container.viewContextlet user = User(context: context)user.name = "Иван"user.age = 30

try? context.save()

// Requêtelet request: NSFetchRequest<User> = User.fetchRequest()request.predicate = NSPredicate(format: "age > 18")let users = try? context.fetch(request)

2. Realm

Realm est un ORM multiplateforme, spécialement conçu pour les applications mobiles. Il est plus rapide que Core Data pour les opérations de lecture et d'écriture.

Avantages :

• Haute performance (jusqu'à 10x plus rapide que Core Data).
• API simple sans avoir à écrire de SQL.
• Mise à jour automatique des objets (live objects).
• Prise en charge des extensions réactives (RxRealm, Combine).

Inconvénients :

• Format de fichier de base de données propriétaire.
• Taille de base limitée (jusqu'à 2 Go sur iOS).
• Moins de flexibilité pour les requêtes complexes.

Exemple de code (Swift) :

import RealmSwift

// Définition du modèleclass User: Object {    @Persisted var name: String = ""    @Persisted var age: Int = 0}

// Sauvegardelet realm = try! Realm()let user = User()user.name = "Мария"user.age = 25

try! realm.write {    realm.add(user)}

// Requêtelet users = realm.objects(User.self).filter("age > 18")for user in users {    print("\\(user.name): \\(user.age)")}

3. GRDB

GRDB est une bibliothèque moderne pour travailler avec SQLite en Swift. Elle combine les capacités d'accès bas niveau à SQL et la commodité d'un ORM.

Avantages :

• Performance maximale (SQLite natif).
• Prise en charge de Combine et Swift Concurrency (async/await).
• Contrôle total sur les requêtes SQL.
• Prise en charge des migrations et du versionnement.

Inconvénients :

• Nécessite la connaissance de SQL.
• Moins de "magie" — plus de code manuel.

Exemple de code (Swift) :

import GRDB

// Définition du modèlestruct User: Codable, FetchableRecord, PersistableRecord {    var id: Int64?    var name: String    var age: Int}

// Connexion à la baselet dbQueue = try DatabaseQueue(path: "/path/to/database.sqlite")

// Sauvegardetry dbQueue.write { db in    let user = User(nam