Get data from 4 tables in Android Room

Question

I'm trying to get data from the database using Room, I want to get the data in the format {registration_number, List, List} but I'm getting an error: "Cannot find the parent entity column area_name in ... and my intermediate class" and in fact I hide that maybe I am taking the wrong approach, please guide me, because I am new in this area

to extract the data I use an intermediate class my class is:

data class LastConfiscats(
@ColumnInfo(name = "registration_number")
var slaugh_num: String,
//    @ColumnInfo(name = "area_name",
@Relation(entity = Area::class, parentColumn = "area_name", entityColumn = "name")
var areaName: List<String>,
//    @ColumnInfo(name = "confiscation_name")
@Relation(entity = Confiscation::class, parentColumn = "confiscation_name", entityColumn = "name")
var confiscationName: List<String>

and DAO method to select data:

    @Query("SELECT registration_number,  area.[name] AS area_name, confiscations.[name] AS confiscation_name " +
        "FROM car_body, car_body_confiscations" +
        "INNER JOIN area ON car_body_confiscations.area_id == area.id " +
        "INNER JOIN confiscations ON car_body_confiscations.confiscation_id == confiscations.id " +
        "WHERE car_body.id == car_body_confiscations.car_body_id ORDER BY car_body.id DESC LIMIT :row_count")
fun getLastConfiscats(row_count: Int): LiveData<List<LastConfiscats>>

The linkage scheme between the tables that I am trying to implement is as follows:

There are examples on the internet how to make a relationship between 2 tables but I need to create a relationship between 4 tables.

Please help me to get the data in the right way

UPDATE :

My Area entity is:

 @Entity(tableName = "area")
 data class Area( @PrimaryKey(autoGenerate = true) var id: Int?, var name: String? )

but in my Confiscation entity I also have "name" column:

@Entity(tableName = "confiscations")
data class Confiscation( @PrimaryKey(autoGenerate = true) var id: Int?, var name: String? )

Answer 1

The actual message you are getting is because when you use @Relation the parent MUST exist and be annotated with @Embedded.

The parent and entity columns MUST be columns in the respective classes.

As an example the following will enable you to get a List of Confiscations, with the related CarBody and the respective Areas (note colum names based upon the screen shots):-

data class LastConfiscats(
    @Embedded
    var carBodyConfiscations: Car_Body_Confiscations,
    @Relation(entity = CarBody::class, parentColumn = "car_body_id", entityColumn = "id")
    var carBody: CarBody,
    @Relation(entity = Area::class, parentColumn = "areaId", entityColumn = "id")
    var area: List<Area>
)

You could use the above with a query such as:-

@Query("SELECT * FROM Car_Body_Confiscations")
fun getCardBodyJoinedWithStuff(): List<LastConfiscats>

No JOINS needed. That is because Room builds the underlying SQL. First is basically the copy of the supplied query. After retrieving the Car_Body_Confiscations it then uses queries based upon the field names/@ColumnInfo and runs queries for each Car_Body_Connfiscation.

For each @Relationship it populates the respective fields (1 carBody and the List of Areas) using queries that it builds. Here's and example of part of the code, for the above from the java(generated) for the query above :-

Main (parent query)

@Override
  public List<LastConfiscats> getCardBodyJoinedWithStuff() {
    final String _sql = "SELECT * FROM Car_Body_Confiscations";
    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
    ....

Later Nn (getting the CarBody(s) there will only be 1)

StringBuilder _stringBuilder = StringUtil.newStringBuilder();
_stringBuilder.append("SELECT `id`,`registrationNumber`,`datetime`,`userId`,`testId` FROM `CarBody` WHERE `id` IN (");
final int _inputSize = _map.size();

Even Later On (Areas)

StringBuilder _stringBuilder = StringUtil.newStringBuilder();
_stringBuilder.append("SELECT `id`,`name` FROM `Area` WHERE `id` IN (");

Now if you want to code your own JOINS etc and alias columns then you will have to consider a few things.

The receiving class MUST be able to be built from the result set and thus column names MUST match the fields in the POJO (unless using @Prefix annotation).

You also need to be aware that the result set will be the cartesian product, thus in the case of doing the above, bypassing how Room does it, the for each combination/permutation of confiscation/carbody/area you get a row (unless grouped/excluded by where clause). So if you have 1 confiscation joined to 1 car but with 10 areas then you would get 10 rows all with the same confiscation and carbody.

You may wish to consider having a look at Room @Relation annotation with a One To Many relationship. Which explains this a little more and includes an example of using a JOINs

Additional - User and TestLists

You may well want to include the CarBody's User and the Test_Lists so you have a result with all of the related data.

This needs to be looked at from a hierarchical perspective. That is the confiscation has a direct link/reference/map to the CarBody but underneath that are the links/references/mappings to the User from the CarBody and to the Test_Lists.

So to incorporate this you need a POJO for a CarBody with it's User and it's Test_Lists. So, for example:-

data class CarBodyWithUserAndWithTestList(
    @Embedded
    var carBody: CarBody,
    @Relation(
        entity = Users::class,
        parentColumn = "userId",
        entityColumn = "id"
    )
    var users: Users,
    @Relation(
        entity = Test_List::class,
        parentColumn = "testId",
        entityColumn = "id"
    )
    var testList: List<Test_List>
)

With this you can then amend the LastConfiscats to include a CarBodyWithUserAndWithTestList instead of just a CarBody e.g.:

data class LastConfiscats(
    @Embedded
    var carBodyConfiscations: Car_Body_Confiscations,
    @Relation(entity = CarBody::class, parentColumn = "car_body_id", entityColumn = "id")
    //var carBody: CarBody, /* REMOVED */
    var carBodyWithUserAndWithTestList: CarBodyWithUserAndWithTestList, /* ADDED */
    @Relation(entity = Area::class, parentColumn = "areaId", entityColumn = "id")
    var area: List<Area>
)

• Note that the @Relation has the CarBody class as the entity. That is because the CarBody is the class that needs to be inspected in order for Room to ascertain the columns used for the links/references/,mappings.

---

*Working Example/Demo

---

Here's the entire code for a Working example that inserts some data into all the tables and then extracts the data using the getCardBodyJoinedWithStuff query, it then writes the data to the Log.

• the code includes ForeignKey constraints which enforces and helps to maintain referential integrity.
• for id's Long rather than Int has been used as Long properly reflects the potential size of the field/value.
• autoGenerate = true has not been used as this is inefficient and not needed see https://sqlite.org/autoinc.html, which includes as the very first statement The AUTOINCREMENT keyword imposes extra CPU, memory, disk space, and disk I/O overhead and should be avoided if not strictly needed. It is usually not needed. (autoGenerate = true results in AUTOINCREMENT)

So all the classes/interfaces :-

@Entity(
    foreignKeys = [
        ForeignKey(
            Users::class,
            parentColumns = ["id"],
            childColumns = ["userId"],
            onDelete = ForeignKey.CASCADE,
            onUpdate = ForeignKey.CASCADE
        ),
        ForeignKey(
            Test_List::class,
            parentColumns = ["id"],
            childColumns = ["testId"],
            onDelete = ForeignKey.CASCADE,
            onUpdate = ForeignKey.CASCADE
        )
    ]
)
data class CarBody(
    @PrimaryKey
    var id: Long?=null,
    var registrationNumber: Int,
    var datetime: String,
    @ColumnInfo(index = true)
    var userId: Long,
    @ColumnInfo(index = true)
    var testId: Long
)
@Entity
data class Users(
    @PrimaryKey
    var  id:Long?=null,
    var name: String,
    var lastName: String,
    var email: String,
    var password: String
)
@Entity
data class Test_List(
    @PrimaryKey
    var id: Long?=null,
    var date: String,
    var is_saved: Boolean
)
@Entity(
    foreignKeys = [
        ForeignKey(
            entity = CarBody::class,
            parentColumns = ["id"],
            childColumns = ["car_body_id"],
            onDelete = ForeignKey.CASCADE,
            onUpdate = ForeignKey.CASCADE
        ),
        ForeignKey(
            entity = Confiscation::class,
            parentColumns = ["id"],
            childColumns = ["confiscation_id"],
            onDelete = ForeignKey.CASCADE,
            onUpdate = ForeignKey.CASCADE
        ),
        ForeignKey(
            entity = Area::class,
            parentColumns = ["id"],
            childColumns = ["areaId"],
            onDelete = ForeignKey.CASCADE,
            onUpdate = ForeignKey.CASCADE
        )
    ]
)
data class Car_Body_Confiscations(
    @PrimaryKey
    var id: Long?=null,
    @ColumnInfo(index = true)
    var car_body_id: Long,
    @ColumnInfo(index = true)
    var confiscation_id: Long,
    @ColumnInfo(index = true)
    var areaId: Long
)
@Entity
data class Area(
    @PrimaryKey
    var id: Long?=null,
    var name: String
)
@Entity
data class Confiscation(
    @PrimaryKey
    var id: Long?=null,
    var name: String
)
@Dao
interface AllDao {

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(area: Area): Long
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(carBodyConfiscations: Car_Body_Confiscations): Long
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(carBody: CarBody): Long
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(confiscation: Confiscation): Long
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(users: Users): Long
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(testList: Test_List): Long

    @Transaction
    @Query("SELECT * FROM Car_Body_Confiscations")
    fun getCardBodyJoinedWithStuff(): List<LastConfiscats>

}
@Database(entities = [
    Area::class,
    Car_Body_Confiscations::class,
    CarBody::class,
    Confiscation::class,
    Users::class,
    Test_List::class
                     ],
    exportSchema = false, version = 1)
abstract class TheDatabase: RoomDatabase() {
    abstract fun getAllDao(): AllDao
    companion object {
        private var instance: TheDatabase?=null
        fun getInstance(context: Context): TheDatabase {
            if (instance==null) {
                instance = Room.databaseBuilder(context,TheDatabase::class.java,"the_database.db")
                    .allowMainThreadQueries()
                    .build()
            }
            return instance as TheDatabase
        }
    }
}

data class LastConfiscats(
    @Embedded
    var carBodyConfiscations: Car_Body_Confiscations,
    @Relation(entity = Confiscation::class, parentColumn = "confiscation_id", entityColumn = "id")
    var confiscation: Confiscation,
    @Relation(entity = CarBody::class, parentColumn = "car_body_id", entityColumn = "id")
    //var carBody: CarBody, /* REMOVED */
    var carBodyWithUserAndWithTestList: CarBodyWithUserAndWithTestList, /* ADDED */
    @Relation(entity = Area::class, parentColumn = "areaId", entityColumn = "id")
    var area: List<Area>
)

data class CarBodyWithUserAndWithTestList(
    @Embedded
    var carBody: CarBody,
    @Relation(
        entity = Users::class,
        parentColumn = "userId",
        entityColumn = "id"
    )
    var users: Users,
    @Relation(
        entity = Test_List::class,
        parentColumn = "testId",
        entityColumn = "id"
    )
    var testList: List<Test_List>
)

The following activity code (note that main thread used for brevity and convenience):-

class MainActivity : AppCompatActivity() {

    lateinit var db: TheDatabase
    lateinit var dao: AllDao
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        db = TheDatabase.getInstance(this)
        dao = db.getAllDao()


        dao.insert(Users(100,"Fred","Bloggs","[email protected]","password"))
        dao.insert(Users(200,"Jane","Doe","[email protected]","password"))
        /* example where id is autogenerated */
        val marySmithId = dao.insert(Users(name = "Mary", lastName = "Smith", email = "[email protected]", password = "1234567890"))

        dao.insert(Test_List(1,"2022-01-01",false))
        dao.insert(Test_List(2,"2022-02-02",true))

        dao.insert(CarBody(1000,1234,"2022-01-01",100 /* Fred Bloggs*/,2 ))
        dao.insert(CarBody(2000,4321,"2021-12-05",100,1))
        dao.insert(CarBody(3000,1111,"2021-09-10",200,2))

        dao.insert(Area(100,"Area100"))
        dao.insert(Area(200,"Area200"))
        dao.insert(Area(300,"Area300"))
        dao.insert(Area(400,"Area400"))

        dao.insert(Confiscation(901,"C1"))
        dao.insert(Confiscation(902,"C2"))
        dao.insert(Confiscation(903,"C3"))
        dao.insert(Confiscation(904,"C4"))

        dao.insert(Car_Body_Confiscations(500,1000,901,100))
        dao.insert(Car_Body_Confiscations(510,2000,904,400))
        dao.insert(Car_Body_Confiscations(520,3000,902,300))

        /* Extract the data and output to the Log */
        for(cbc in dao.getCardBodyJoinedWithStuff()) {
            val areaList = StringBuilder()
            for (a in cbc.area) {
                areaList.append("\n\t\tArea is ${a.name} ID is ${a.id}")
            }
            val testList = StringBuilder()
            testList.append("\n\t\tThere are ${cbc.carBodyWithUserAndWithTestList.testList.size} TestLists, they are:")
            for (t in cbc.carBodyWithUserAndWithTestList.testList) {
                testList.append("\n\t\t\t${t.date} Save is ${t.is_saved} ID is ${t.id}")
            }
            Log.d(
                "DBINFO",
                "CBC ID =${cbc.carBodyConfiscations.id}" +
                        "\n\tConfiscation Name is ${cbc.confiscation.name}" +
                        "\n\tAreas (there is/are ${cbc.area.size}) they are $areaList}" +
                        "\n\tCarBody Reg is ${cbc.carBodyWithUserAndWithTestList.carBody.registrationNumber}  " +
                        "Date is ${cbc.carBodyWithUserAndWithTestList.carBody.datetime}" +
                        "\n\t\tUser is ${cbc.carBodyWithUserAndWithTestList.users.name}" +
                        ",${cbc.carBodyWithUserAndWithTestList.users.lastName} " +
                        "email is ${cbc.carBodyWithUserAndWithTestList.users.email}" +
                        "$testList"
            )
        }
    }
}

Result

The Log after running:-

 D/DBINFO: CBC ID =500
        Confiscation Name is C1
        Areas (there is/are 1) they are 
            Area is Area100 ID is 100}
        CarBody Reg is 1234  Date is 2022-01-01
            User is Fred,Bloggs email is [email protected]
            There are 1 TestLists, they are:
                2022-02-02 Save is true ID is 2
                
                
 D/DBINFO: CBC ID =510
        Confiscation Name is C4
        Areas (there is/are 1) they are 
            Area is Area400 ID is 400}
        CarBody Reg is 4321  Date is 2021-12-05
            User is Fred,Bloggs email is [email protected]
            There are 1 TestLists, they are:
                2022-01-01 Save is false ID is 1
                
                
 D/DBINFO: CBC ID =520
        Confiscation Name is C2
        Areas (there is/are 1) they are 
            Area is Area300 ID is 300}
        CarBody Reg is 1111  Date is 2021-09-10
            User is Jane,Doe email is [email protected]
            There are 1 TestLists, they are:
                2022-02-02 Save is true ID is 2

Re the Comment

I actually have a Cartesian product, I had to process it somehow, although I do not know how yet.

You may find that the above is fine and processes the product pretty easily.

Where Room's relationship handling can become restrictive is if you want to selectively retrieve related data. The way Room handles @Relation means that it retrieves ALL children irrespective of any JOINS and WHERE clauses. They are only effective if they affect the result of the topmost parent.

In your case, where you don't actually cater for lists (such as multiple users per carbody) then Room should suffice.

---

The original Query - revisited

---

Changing your query a little to (largely to suit the previous classes ) to:-

@Query("SELECT " +
        "registrationNumber,  " +
        "area.[name] AS area_name, " +
        "confiscation.[name] AS confiscation_name " +
        "FROM carbody, car_body_confiscations " +
        "INNER JOIN area ON car_body_confiscations.areaId == area.id " +
        "INNER JOIN confiscation ON car_body_confiscations.confiscation_id == confiscation.id " +
        "WHERE carbody.id == car_body_confiscations.car_body_id " +
        "ORDER BY carbody.id DESC " +
        "LIMIT :row_count"
)
fun getLastConfiscats(row_count: Int): /*LiveData<*/List<MyQueryPOJO>/*>*/

• see the following re MyQueryPOJO

And adding a suitable class (no @Embeddeds or @Relations needed, so Room doesn't get confused with column names) :-

data class MyQueryPOJO(
    /* The output columns of the query */
    var registrationNumber: Int,
    @ColumnInfo(name = "area_name")
    var not_the_area_name: String,
    var confiscation_name: String
)

• note how the not_the_area_name field has the @ColumnInfo annotation to tell it to use the area_name output column

In the activity, using:-

    for (mqo in dao.getLastConfiscats(10)) {
        Log.d("DBINFO","Reg = ${mqo.registrationNumber} Confiscation = ${mqo.confiscation_name} Area Name = ${mqo.not_the_area_name}")
    }

Results in (with the same data) :-

D/DBINFO: Reg = 1111 Confiscation = C2 Area Name = Area300
D/DBINFO: Reg = 4321 Confiscation = C4 Area Name = Area400
D/DBINFO: Reg = 1234 Confiscation = C1 Area Name = Area100

• as the relationships all all basically 1-1 (the references are back to front for a 1-many) the cartesian product is fine as there will not be any duplicates.