Android Academy · Leçon

Requêtes et relations

Interrogez les données et reliez les entités.

Requêtes et relations est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Au-delà d’une seule table

Les applications réelles contiennent des données associées : un utilisateur possède plusieurs publications, une commande possède plusieurs articles. Room les modélise avec des clés étrangères et l’annotation @Relation.

Requêtes paramétrées

Transmettez des arguments à une @Query en les faisant précéder de deux-points.

@Query("SELECT * FROM users WHERE name LIKE :search")
suspend fun search(search: String): List<User>

Renvoyer des agrégats

Les requêtes peuvent renvoyer des valeurs scalaires telles que des nombres d’éléments.

@Query("SELECT COUNT(*) FROM users")
suspend fun count(): Int

Définir une clé étrangère

Une entité enfant fait référence à son parent avec @ForeignKey. Cela garantit l’intégrité référentielle au niveau de la base de données.

@Entity(
    foreignKeys = [ForeignKey(
        entity = User::class,
        parentColumns = ["id"],
        childColumns = ["userId"]
    )]
)
data class Post(
    @PrimaryKey val id: Int,
    val userId: Int,
    val title: String
)

Indexer les clés étrangères

Room recommande d’indexer les colonnes de clés étrangères pour améliorer les performances des requêtes. Ajoutez un @Index.

@Entity(
    indices = [Index("userId")]
)
data class Post(/* ... */ val userId: Int)

Comportement de onDelete

Décidez de ce qui arrive aux enfants lorsqu’un parent est supprimé, par exemple utilisez CASCADE pour les supprimer également.

ForeignKey(
    entity = User::class,
    parentColumns = ["id"],
    childColumns = ["userId"],
    onDelete = ForeignKey.CASCADE
)

Modéliser une relation un-à-plusieurs

Créez une classe qui combine un parent avec ses enfants à l’aide de @Embedded et @Relation.

data class UserWithPosts(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "userId"
    )
    val posts: List<Post>
)

Interroger la relation

Renvoyez la classe combinée depuis un DAO. Room exécute la requête supplémentaire et assemble les objets.

@Transaction
@Query("SELECT * FROM users")
suspend fun getUsersWithPosts(): List<UserWithPosts>

Pourquoi utiliser @Transaction ici

Comme Room exécute deux requêtes (les parents, puis les enfants), placer la méthode dans @Transaction garantit un instantané cohérent, sans écritures intercalées.

Relation plusieurs-à-plusieurs avec une table de jointure

Pour une relation plusieurs-à-plusieurs (étudiants et cours), utilisez une table de jointure et le paramètre associateBy de @Relation.

@Relation(
    parentColumn = "studentId",
    entityColumn = "courseId",
    associateBy = Junction(Enrollment::class)
)
val courses: List<Course>

Résumé des relations

@ForeignKey impose l'intégrité et les règles de propagation.
@Relation et @Embedded assemblent les objets associés.
@Transaction garantit la cohérence des lectures comportant plusieurs requêtes.

Vérification rapide

Testez votre compréhension des relations.

Récapitulatif

Vous avez appris à :

Paramétrer les requêtes avec :name et renvoyer des agrégats.
@ForeignKey impose l'intégrité avec les règles onDelete.
@Relation et @Embedded construisent des objets associés ; encapsulez les lectures dans @Transaction.

Questions Fréquemment Posées

La leçon « Requêtes et relations » est-elle gratuite ?

Oui — le texte complet de « Requêtes et relations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Requêtes et relations » ?

Interrogez les données et reliez les entités. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Requêtes et relations » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy