Definire e eseguire query sulle relazioni one-to-one

Una relazione uno a uno tra due entità è una relazione in cui ogni istanza dell'entità principale corrisponde a esattamente un'istanza dell'entità secondaria e viceversa.

Ad esempio, prendi in considerazione un'app di streaming musicale in cui l'utente ha una raccolta di brani di sua proprietà. Ogni utente ha una sola raccolta e ogni raccolta corrisponde esattamente a un utente. Pertanto, esiste una relazione one-to-one tra l'entità User e l'entità Library.

Per definire e eseguire query sulle relazioni uno a uno nel database:

1. Definisci la relazione: crea classi per entrambe le entità, assicurandoti che una faccia riferimento alla chiave primaria dell'altra.
2. Esegui query sulle entità: modella la relazione in una nuova classe di dati e crea un metodo per recuperare i dati correlati.

Definisci la relazione

Per definire una relazione uno a uno, crea innanzitutto un corso per ciascuna delle due entità. Una delle entità deve includere una variabile che è un riferimento alla chiave primaria dell'altra entità.

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Library(
    @PrimaryKey val libraryId: Long,
    val userOwnerId: Long
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Library {
    @PrimaryKey public long libraryId;
    public long userOwnerId;
}

Esegui una query sulle entità

Per eseguire query sull'elenco di utenti e sulle librerie corrispondenti, devi prima modellare la relazione uno a uno tra le due entità.

A tale scopo, crea una nuova classe di dati in cui ogni istanza contiene un'istanza dell'entità principale e l'istanza corrispondente dell'entità secondaria. Aggiungi l'annotazione @Relation all'istanza dell'entità secondaria, con parentColumn impostato sul nome della colonna della chiave primaria dell'entità principale e entityColumn impostato sul nome della colonna dell'entità secondaria che fa riferimento alla chiave primaria dell'entità principale.

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    val library: Library
)

public class UserAndLibrary {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    public Library library;
}

Infine, aggiungi un metodo alla classe DAO che restituisca tutte le istanze della classe di dati che accoppiano l'entità principale e l'entità secondaria. Questo metodo richiede che Room esegua due query. Dovresti quindi aggiungere l'annotazione @Transaction a questo metodo. In questo modo, l'intera operazione viene eseguita in modo atomico.

@Transaction
@Query("SELECT * FROM User")
fun getUsersAndLibraries(): List<UserAndLibrary>

@Transaction
@Query("SELECT * FROM User")
public List<UserAndLibrary> getUsersAndLibraries();