Type de retour pour Android Room joins

Question

Supposons que je veuille faire un INNER JOIN entre deux entités Foo y Bar :

@Query("SELECT * FROM Foo INNER JOIN Bar ON Foo.bar = Bar.id")
List<FooAndBar> findAllFooAndBar();

Est-il possible de forcer un type de retour comme celui-ci ?

public class FooAndBar {
    Foo foo;
    Bar bar;
}

Lorsque j'essaie de le faire, j'obtiens cette erreur :

error: Cannot figure out how to read this field from a cursor.

J'ai également essayé d'aliaser les noms des tables pour qu'ils correspondent aux noms des champs, mais cela n'a pas fonctionné non plus.

Si ce n'est pas possible, comment puis-je construire proprement un type de retour compatible qui inclut tous les champs des deux entités ?

Answer 1

Dao

@Query("SELECT * FROM Foo")
List<FooAndBar> findAllFooAndBar();

Classe FooAndBar

public class FooAndBar {
    @Embedded
    Foo foo;

    @Relation(parentColumn =  "Foo.bar_id", entityColumn = "Bar.id")
    List<Bar> bar;
    // If we are sure it returns only one entry
    // Bar bar;

    //Getter and setter...
}

Cette solution semble fonctionner, mais je n'en suis pas très fier. Qu'en pensez-vous ?

Edit : Une autre solution

Dao, je préfère sélectionner explicitement mais "*" fera l'affaire :) Gardez à l'esprit que cette solution ne fonctionne que lorsque les champs des deux entités sont uniques. Voir les commentaires pour plus d'informations.

@Query("SELECT Foo.*, Bar.* FROM Foo INNER JOIN Bar ON Foo.bar = Bar.id")
List<FooAndBar> findAllFooAndBar();

Classe FooAndBar

public class FooAndBar {
    @Embedded
    Foo foo;

    @Embedded
    Bar bar;

    //Getter and setter...
}

edit : depuis la version 2.2.0-alpha01, l'annotation room @Relation peut gérer des relations One-To-One

Answer 2

Une autre option consiste à écrire un nouveau POJO représentant la structure résultante de votre requête JOIN (qui prend même en charge le renommage des colonnes pour éviter les conflits) :

@Dao
public interface FooBarDao {
   @Query("SELECT foo.field1 AS unique1, bar.field1 AS unique2 "
          + "FROM Foo INNER JOIN Bar ON Foo.bar = Bar.id")
   public List<FooBar> getFooBars();

   static class FooBar {
       public String unique1;
       public String unique2;
   }
}    

Voir : room/accessing-data.html#query-multiple-tables

Answer 3

Essayez cette méthode. Par exemple, j'ai des relations M2M (many-to-many) entre Product y Attribute . Nombreux Produits ont de nombreux Attributs et je dois obtenir tous les Attributs por Product.id avec des enregistrements triés par PRODUCTS_ATTRIBUTES.DISPLAY_ORDERING .

|--------------|  |--------------|  |-----------------------|
| PRODUCT      |  | ATTRIBUTE    |  | PRODUCTS_ATTRIBUTES   |
|--------------|  |--------------|  |-----------------------|
| _ID:  Long   |  | _ID: Long    |  | _ID: Long             |
| NAME: Text   |  | NAME: Text   |  | _PRODUCT_ID: Long     |
|______________|  |______________|  | _ATTRIBUTE_ID: Long   |
                                    | DISPLAY_ORDERING: Int |
                                    |_______________________|

Les modèles seront donc les suivants :

@Entity(
    tableName = "PRODUCTS",
    indices = [
        Index(value = arrayOf("NAME"), unique = true)
    ]
)
class Product {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "_ID")
    var _id: Long = 0

    @ColumnInfo(name = "NAME")
    @SerializedName(value = "NAME")
    var name: String = String()

}

@Entity(
    tableName = "ATTRIBUTES",
    indices = [
        Index(value = arrayOf("NAME"), unique = true)
    ]
)
class Attribute {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "_ID")
    var _id: Long = 0

    @ColumnInfo(name = "NAME")
    @SerializedName(value = "NAME")
    var name: String = String()

}

Et la table "join" sera :

@Entity(
    tableName = "PRODUCTS_ATTRIBUTES",
    indices = [
        Index(value = ["_PRODUCT_ID", "_ATTRIBUTE_ID"])
    ],
    foreignKeys = [
        ForeignKey(entity = Product::class, parentColumns = ["_ID"], childColumns = ["_PRODUCT_ID"]),
        ForeignKey(entity = Attribute::class, parentColumns = ["_ID"], childColumns = ["_ATTRIBUTE_ID"])
    ]
)
class ProductAttribute {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "_ID")
    var _id: Long = 0

    @ColumnInfo(name = "_PRODUCT_ID")
    var _productId: Long = 0

    @ColumnInfo(name = "_ATTRIBUTE_ID")
    var _attributeId: Long = 0

    @ColumnInfo(name = "DISPLAY_ORDERING")
    var displayOrdering: Int = 0

}

En, AttributeDAO pour obtenir tous les attributs basés sur Product._ID vous pouvez faire quelque chose comme ci-dessous :

@Dao
interface AttributeDAO {

    @Query("SELECT ATTRIBUTES.* FROM ATTRIBUTES INNER JOIN PRODUCTS_ATTRIBUTES ON PRODUCTS_ATTRIBUTES._ATTRIBUTE_ID = ATTRIBUTES._ID INNER JOIN PRODUCTS ON PRODUCTS._ID = PRODUCTS_ATTRIBUTES._PRODUCT_ID WHERE PRODUCTS._ID = :productId ORDER BY PRODUCTS_ATTRIBUTES.DISPLAY_ORDERING ASC")
    fun getAttributesByProductId(productId: Long): LiveData<List<Attribute>>

}

Si vous avez des questions, n'hésitez pas à me les poser.

Answer 4

Est-il possible de forcer un type de retour comme celui-ci ?

Vous pouvez essayer @Embedded annotations sur foo y bar . Cela indiquera à Room d'essayer de prendre les colonnes de votre requête et de les verser dans foo y bar instances. Je n'ai essayé qu'avec des entités, mais la documentation indique que cela devrait également fonctionner avec des POJO.

Cependant, cela peut ne pas fonctionner si vos deux tables ont des colonnes portant le même nom.

Answer 5

Voici ma table d'alimentation

@Entity(tableName = "_food_table")
data class Food(@PrimaryKey(autoGenerate = false)
            @ColumnInfo(name = "_food_id")
            var id: Int = 0,
            @ColumnInfo(name = "_name")
            var name: String? = "")

Voici la table et la classe de modèle de mon panier (Food Cart)

@Entity(tableName = "_client_cart_table")
data class CartItem(
                @PrimaryKey(autoGenerate = false)
                @ColumnInfo(name = "_food_id")
                var foodId: Int? = 0,
                @Embedded(prefix = "_food")
                var food: Food? = null,
                @ColumnInfo(name = "_branch_id")
                var branchId: Int = 0)

Remarque : nous voyons ici la colonne _food_id dans deux tableaux. Cela provoquera une erreur au moment de la compilation. D'après la documentation @Embedded, vous devez utiliser un préfixe pour les différencier.

A l'intérieur du dao

@Query("select * from _client_cart_table inner join _food_table on _client_cart_table._food_id = _food_table._food_id where _client_cart_table._branch_id = :branchId")
fun getCarts(branchId: Int) : LiveData<List<CartItem>>

Cette requête renverra des données comme suit

CartItem(foodId=5, food=Food(id=5, name=Black Coffee), branchId=1)

C'est ce que j'ai fait dans mon projet. Essayez donc. Bon codage