RawQuery cannot compile: "Cannot figure out how to read this field from a cursor." - android-room

Question

I've multiple #RawQuerys in my project with custom data classes as return type and this worked well so far, but now I'm trying to have a data class with a List<OtherResult> property and this fails at compile time with:
error: Cannot figure out how to read this field from a cursor.
So basically:
data class CustomResult(
val count: Int,
val name: String,
val values: List<SubResult>,
)
data class SubResult(
val sub_name: String,
val sub_code: String,
)
------
Dao:
#RawQuery
abstract fun getCustomResultRaw(query: SimpleSQLiteQuery): List<CustomResult>
fun getCustomResult(): List<CustomResult> {
val params = emptyArray<Any>()
val query = "SELECT ..... "
return getCustomResultRaw(SimpleSQLiteQuery(query, params))
}
Is there any way to force-tell room that the List<> property should be parsed as SubResult? What other options do I have?

Answer 1

Is there any way to force-tell room that the List<> property should be parsed as SubResult?
No not like that. Room stores data in SQLite tables, that consist of columns and only a limited set of types those being, from an SQLite perspective:-
NULL
INTEGER (64 bit signed integer e.g. Long, Int, Byte ...)
TEXT (character string e.g. String)
REAL (8-byte IEEE floating point number e.g. Double, Float ...)
BLOB (a stream of Bytes e.g. ByteArray)
NUMERIC (any of the above BUT not supported by ROOM)
A column cannot directly contain multiple values such as a list.
What other options do I have?
Basically two options:-
Store the SubResult values in another table with a relationship to the CustomResult, this would be the way from a relational database perspective.
CustomResult would be the parent, SubResult would be the child (children)
Store the SubResults as one of the allowable types (probably rules out INTEGER or REAL, rules out NULL), so you would need to Convert that data to either a ByteArray or a String. Typically the latter is used and the String is a JSON representation of the data. You then need to define TypeConverters to let ROOM know how to handle the conversion.
Working Example
The following is an example that uses both methods.
NOTE to cater for conversion of a list of SubResults the Google Gson library was added dependency implementation 'com.google.code.gson:gson:2.9.0' (no need for this if using the second table with related SubResults)
Here's the data classes:-
data class CustomResult(
val count: Int,
val name: String,
/*val values: List<SubResult>, uses SubResultList to cater for Type Converters*/
val values: SubResultList /* Not required if using table for SubResults */
)
data class SubResult(
val sub_name: String,
val sub_code: String,
)
/* Holder for List to suit conversion of SubResult List - Not needed if using table for SubResults*/
data class SubResultList(
val srList: List<SubResult>
)
/* Primary Table for the CR's (as well as the converted list of SubResults)*/
#Entity
data class CRTable(
#PrimaryKey
val crId: Long?=null, /* Uniquely Identifies the CR Row - generated if null */
#Embedded
val customResult: CustomResult
)
/* Second table for the SR's - not needed if using JSON representation of SR List*/
#Entity
data class SRTable(
#PrimaryKey
val srId: Long?=null,
#ColumnInfo(index = true)
val parentCrId: Long,
#Embedded
val subResult: SubResult
)
/* For retrieving the CRTables WITH the related SRTable rows - not needed if using JSON representation of SR List*/
data class CRTableWithRelatedSRTables(
#Embedded
val crTable: CRTable,
#Relation(entity = SRTable::class, parentColumn = "crId", entityColumn = "parentCrId")
val srTableList: List<SRTable>
)
The Converters (2) to convert a SubResultList to JSON and back:-
class Converters {
#TypeConverter
fun convertSubResultListToJSONString(subResultList: SubResultList): String = Gson().toJson(subResultList)
#TypeConverter
fun convertJSONStringToSubResultList(jsonString: String): SubResultList = Gson().fromJson(jsonString,SubResultList::class.java)
}
The DAO interface (functions to access the database) :-
#Dao
interface AllDao {
#Insert(onConflict = OnConflictStrategy.IGNORE)
fun insert(crTable: CRTable): Long
/* Not Needed if storing Subresults as an embedded list */
#Insert(onConflict = OnConflictStrategy.IGNORE)
fun insert(srTable: SRTable): Long
/* Query for embedded Subresults list */
#Query("SELECT * FROM crtable")
fun getAllCRTableRows(): List<CRTable>
/* Query for both embedded Subresults (as they are combned in this example) and the related SRTable rows */
#Transaction
#Query("SELECT * FROM crtable")
fun getAllCRTablesWithRelatedSRTables(): List<CRTableWithRelatedSRTables>
}
An #Database annotated class with a singleton for the instance. Note for brevity and convenience allows running on the main thread.
#TypeConverters(value = [Converters::class])
#Database(entities = [CRTable::class,SRTable::class], version = 1, exportSchema = false)
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
}
}
}
if using just the two tables, then #TypConverters would not need to be defined.
if just embedding the SubResultsList then the SRTable class would not be included in the entities parameter
Finally putting it all together in an activity:-
const val TAG = "DBINFO"
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()
/* Preapre some SubResults */
val sr01 = SubResult("SR01","CODEA")
val sr02 = SubResult("SR02","CODEB")
val sr03 = SubResult("SR03","CODEC")
val sr04 = SubResult("SR04","CODED")
val sr05 = SubResult("SR05","CODEE")
/* Prepare some SubResultLists */
val srl1 = SubResultList(listOf(sr01,sr02,sr03))
val srl2 = SubResultList(listOf(sr04,sr05))
val srl3 = SubResultList(listOf(sr01,sr02,sr03,sr04,sr05))
/* Add CustomResults for embedded SubresultList (i.e. converted to JSON)*/
val cr01 = dao.insert(CRTable(customResult = CustomResult(1,"CR01",srl1)))
val cr02 = dao.insert(CRTable(customResult = CustomResult(2,"CR02",srl2)))
val cr03 = dao.insert(CRTable(customResult = CustomResult(3,"CR03",srl3)))
/* Add the related SRTable rows (each block is per parent CustomResult) */
dao.insert(SRTable(null,cr01,sr01))
dao.insert(SRTable(null,cr01,sr02))
dao.insert(SRTable(null,cr01,sr03))
dao.insert(SRTable(null,cr02,sr04))
dao.insert(SRTable(null,cr02,sr05))
dao.insert(SRTable(null,cr03,sr01))
dao.insert(SRTable(null,cr03,sr02))
dao.insert(SRTable(null,cr03,sr03))
dao.insert(SRTable(null,cr03,sr04))
dao.insert(SRTable(null,cr03,sr05))
/* Extract and inspect the data (only need the more complex query as CRTable has the embedded SubResultsList) */
for (crwsr in dao.getAllCRTablesWithRelatedSRTables()) {
/* For each CRTable row */
Log.d(TAG,"CRTable is ${crwsr.crTable.customResult.name} count is ${crwsr.crTable.customResult.count} it has ${crwsr.crTable.customResult.values.srList.size} SR's, it also has ${crwsr.srTableList.size} related SRTable rows.")
Log.d(TAG,"SR's are:-")
/* For each item in the SubResultList (for the current CustomResult) */
for (sr in crwsr.crTable.customResult.values.srList) {
Log.d(TAG,"\tSR is ${sr.sub_name} code is ${sr.sub_code}")
}
Log.d(TAG,"Related SR's are:-")
/* For each related row in the SRTable (for the current CustomResult) */
for (srt in crwsr.srTableList) {
Log.d(TAG,"\tSR is ${srt.subResult.sub_name} code is ${srt.subResult.sub_code} ID is ${srt.srId} related to (child of) CR with an ID of ${srt.parentCrId}")
}
}
}
}
Results
The log includes:-
2022-06-10 05:54:48.982 D/DBINFO: CRTable is CR01 count is 1 it has 3 SR's, it also has 3 related SRTable rows.
2022-06-10 05:54:48.982 D/DBINFO: SR's are:-
2022-06-10 05:54:48.982 D/DBINFO: SR is SR01 code is CODEA
2022-06-10 05:54:48.982 D/DBINFO: SR is SR02 code is CODEB
2022-06-10 05:54:48.982 D/DBINFO: SR is SR03 code is CODEC
2022-06-10 05:54:48.982 D/DBINFO: Related SR's are:-
2022-06-10 05:54:48.982 D/DBINFO: SR is SR01 code is CODEA ID is 1 related to (child of) CR with an ID of 1
2022-06-10 05:54:48.982 D/DBINFO: SR is SR02 code is CODEB ID is 2 related to (child of) CR with an ID of 1
2022-06-10 05:54:48.982 D/DBINFO: SR is SR03 code is CODEC ID is 3 related to (child of) CR with an ID of 1
2022-06-10 05:54:48.983 D/DBINFO: CRTable is CR02 count is 2 it has 2 SR's, it also has 2 related SRTable rows.
2022-06-10 05:54:48.983 D/DBINFO: SR's are:-
2022-06-10 05:54:48.983 D/DBINFO: SR is SR04 code is CODED
2022-06-10 05:54:48.983 D/DBINFO: SR is SR05 code is CODEE
2022-06-10 05:54:48.983 D/DBINFO: Related SR's are:-
2022-06-10 05:54:48.983 D/DBINFO: SR is SR04 code is CODED ID is 4 related to (child of) CR with an ID of 2
2022-06-10 05:54:48.983 D/DBINFO: SR is SR05 code is CODEE ID is 5 related to (child of) CR with an ID of 2
2022-06-10 05:54:48.983 D/DBINFO: CRTable is CR03 count is 3 it has 5 SR's, it also has 5 related SRTable rows.
2022-06-10 05:54:48.983 D/DBINFO: SR's are:-
2022-06-10 05:54:48.983 D/DBINFO: SR is SR01 code is CODEA
2022-06-10 05:54:48.983 D/DBINFO: SR is SR02 code is CODEB
2022-06-10 05:54:48.983 D/DBINFO: SR is SR03 code is CODEC
2022-06-10 05:54:48.984 D/DBINFO: SR is SR04 code is CODED
2022-06-10 05:54:48.984 D/DBINFO: SR is SR05 code is CODEE
2022-06-10 05:54:48.984 D/DBINFO: Related SR's are:-
2022-06-10 05:54:48.984 D/DBINFO: SR is SR01 code is CODEA ID is 6 related to (child of) CR with an ID of 3
2022-06-10 05:54:48.984 D/DBINFO: SR is SR02 code is CODEB ID is 7 related to (child of) CR with an ID of 3
2022-06-10 05:54:48.984 D/DBINFO: SR is SR03 code is CODEC ID is 8 related to (child of) CR with an ID of 3
2022-06-10 05:54:48.984 D/DBINFO: SR is SR04 code is CODED ID is 9 related to (child of) CR with an ID of 3
2022-06-10 05:54:48.984 D/DBINFO: SR is SR05 code is CODEE ID is 10 related to (child of) CR with an ID of 3
i.e. the expected result (3 SRs for the first CR, 2 SRs for the second CR and 5 SRs for the third CR for BOTH methods)
The actual data stored:-
CRTable has 3 rows :-
As can be seen the values has the List of SubResults (as a SubResultsList). The disadvantage would be querying the data, say if you wanted just the CRs that had a specific SR code you can't just say WHERE values = 'CODEE', you might get away with WHERE values LIKE '%CODEE%' (but that's inefficient as it requires a Full Table Scan). Also as can be seen there is a lot of BLOAT stored due to the JSON syntax and naming.
SRTable has a row per related SR so 10 rows:-
far less data is stored
searches would like be via index (SQLite Query Optimizer will do it's business)
the SELECT SQL can be more complicated (especially when Room's conveniences aren't suitable e.g. the query in the example uses subqueries built by Room to get the related SR's rows and that is for ALL related (hence the #Transaction).)

Answer 2

I couldn't solve my problem, but found a workaround using multimap as described in the documentation, ie. in this case returning a Map<CustomResult, List<SubResult>>:
The main class holding the List<> goes like:
data class CustomResult(
val count: Int,
val name: String,
) {
#Ignore
var values: List<SubResult> = emptyList() // note: `var` instead of `val`
}
The Dao functions then go like this:
// now returning a Map<>
#RawQuery
abstract fun getCustomResultRaw(query: SimpleSQLiteQuery): Map<CustomResult, List<SubResult>>
// maps the Map<> to a List<>
fun getCustomResult(): List<CustomResult> {
val params = emptyArray<Any>()
val query = "SELECT ..... "
val resultMap = getCustomResultRaw(SimpleSQLiteQuery(query, params))
return resultMap.map { e ->
CustomResult(
count = e.key.count,
name = e.key.name,
).apply {
values = e.value
}
}
}