Cómo definir y consultar relaciones de uno a uno

En las relaciones de uno a uno entre dos entidades, cada instancia de la entidad principal corresponde a una sola instancia de la entidad secundaria y viceversa.

Por ejemplo, imagina una app de transmisión de música en la que el usuario tiene una biblioteca de canciones de su propiedad. Cada usuario tiene una sola biblioteca y cada biblioteca corresponde exactamente a un usuario. Por lo tanto, existe una relación de uno a uno entre la entidad User y la entidad Library.

Sigue estos pasos para definir y consultar relaciones de uno a uno en tu base de datos:

  1. Define la relación: Crea clases para ambas entidades y asegúrate de que una haga referencia a la clave primaria de la otra.
  2. Consulta las entidades: Modela la relación en una nueva clase de datos, y crea una función para recuperar los datos relacionados.

Define la relación

Para definir una relación de uno a uno, primero crea una clase para cada una de las dos entidades. Una de las entidades debe incluir una variable que haga referencia a la clave primaria de la otra entidad.

@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
)

Consulta las entidades

Para consultar la lista de usuarios y las bibliotecas correspondientes, primero debes modelar la relación de uno a uno entre las dos entidades.

Para modelar la relación, crea una clase de datos nueva en la que cada instancia tenga una instancia de la entidad principal y la entidad secundaria correspondiente. Agrega la @Relation anotación a la entidad secundaria. Establece parentColumns en el nombre de la columna de clave primaria de la entidad principal y establece entityColumns en el nombre de la columna de la entidad secundaria que hace referencia a la clave primaria de la entidad principal.

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["userId"],
        entityColumns = ["userOwnerId"]
    )
    val library: Library
)

Por último, agrega una función a la clase de objeto de acceso a datos (DAO) que muestre todas las instancias de la clase de datos que vincula la entidad principal con la secundaria. Agrega la anotación @Transaction para asegurarte de que Room realice toda la operación de forma automática, ya que esta función requiere que Room ejecute dos consultas.

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

Claves compuestas

Si defines la relación con claves compuestas, especifica varias columnas en parentColumns y entityColumns. El orden de las columnas en parentColumns debe coincidir con el orden de las columnas en entityColumns.

@Entity(primaryKeys = ["firstName", "lastName"])
data class User(
    val firstName: String,
    val lastName: String,
    val age: Int
)

@Entity
data class Library(
    @PrimaryKey val libraryId: Long,
    val userFirstName: String,
    val userLastName: String
)

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["firstName", "lastName"],
        entityColumns = ["userFirstName", "userLastName"]
    )
    val library: Library
)