How to Read Data From SQLite Database in Android using Jetpack Compose?
Last Updated :
18 May, 2025
In the 1st part of our SQLite database, we have seen How to Create and Add Data to SQLite Database in Android using Jetpack Compose. In that article, we have added data to our SQLite Database. In this article, we will read all this data from the SQLite database and display this data in our ListView using Jetpack Compose.
Refer to the previous article to know how to create data in SQLite Database: How to Create and Add Data to SQLite Database in Android using Jetpack Compose?
What we are going to build in this article?
We will be working on the existing application which we have built in our previous article. In that application, we are simply adding the course list part where we can get to see our list of courses. A sample video is given at the end to get an idea about what we are going to do in this article. Note that we are going to implement this project using the Kotlin language.
Step by Step Implementation
Step 1: Create a New Project in Android Studio
To create a new project in the Android Studio, please refer to How to Create a new Project in Android Studio with Jetpack Compose.
Step 2: Creating a data class each Courses
Navigate to app > kotlin+java > {package-name}, Right-click on it, New > Kotlin class/file and specify its name as CourseModal and add the below code to it.
CourseModal.kt:
Kotlin
package com.geeksforgeeks.demo
data class CourseModal (
val courseName: String,
val courseTracks: String,
val courseDuration: String,
val courseDescription: String
)
In the previous article mentioned above, we created a Database Handler Class named DBHandler.kt to handle out database operation. In this step, we will update this class by adding a function readCourses() to view our data in a list.
DBHandler.kt:
Kotlin
package com.geeksforgeeks.demo
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
// creating a constructor
// for our database handler
class DBHandler
(context: Context?) :
SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {
// below method is for creating a database
// by running a sqlite query
override fun onCreate(db: SQLiteDatabase) {
// on below line we are creating
// an sqlite query and we are
// setting our column names
// along with their data types.
val query = ("CREATE TABLE " + TABLE_NAME + " ("
+ ID_COL + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ NAME_COL + " TEXT,"
+ DURATION_COL + " TEXT,"
+ DESCRIPTION_COL + " TEXT,"
+ TRACKS_COL + " TEXT)")
// at last we are calling a exec sql
// method to execute above sql query
db.execSQL(query)
}
// this method is use to add new
// course to our sqlite database.
fun addNewCourse(
courseName: String?,
courseDuration: String?,
courseDescription: String?,
courseTracks: String?
) {
// on below line we are creating a variable for
// our sqlite database and calling writable method
// as we are writing data in our database.
val db = this.writableDatabase
// on below line we are creating a
// variable for content values.
val values = ContentValues()
// on below line we are passing all values
// along with its key and value pair.
values.put(NAME_COL, courseName)
values.put(DURATION_COL, courseDuration)
values.put(DESCRIPTION_COL, courseDescription)
values.put(TRACKS_COL, courseTracks)
// after adding all values we are passing
// content values to our table.
db.insert(TABLE_NAME, null, values)
// at last we are closing our
// database after adding database.
db.close()
}
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
// this method is called to check if the table exists already.
db.execSQL("DROP TABLE IF EXISTS $TABLE_NAME")
onCreate(db)
}
companion object {
// creating a constant variables for our database.
// below variable is for our database name.
private const val DB_NAME = "coursedb"
// below int is our database version
private const val DB_VERSION = 1
// below variable is for our table name.
private const val TABLE_NAME = "mycourses"
// below variable is for our id column.
private const val ID_COL = "id"
// below variable is for our course name column
private const val NAME_COL = "name"
// below variable id for our course duration column.
private const val DURATION_COL = "duration"
// below variable for our course description column.
private const val DESCRIPTION_COL = "description"
// below variable is for our course tracks column.
private const val TRACKS_COL = "tracks"
}
// we have created a new method for reading all the courses.
fun readCourses(): ArrayList<CourseModal> {
// on below line we are creating a
// database for reading our database.
val db = this.readableDatabase
// on below line we are creating a cursor
// with query to read data from database.
val cursorCourses: Cursor = db.rawQuery("SELECT * FROM $TABLE_NAME", null)
// on below line we are creating a new array list.
val courseModalArrayList: ArrayList<CourseModal> = ArrayList()
// moving our cursor to first position.
if (cursorCourses.moveToFirst()) {
do {
// on below line we are adding the
// data from cursor to our array list.
courseModalArrayList.add(
CourseModal(
cursorCourses.getString(1),
cursorCourses.getString(4),
cursorCourses.getString(2),
cursorCourses.getString(3)
)
)
} while (cursorCourses.moveToNext())
// moving our cursor to next.
}
// at last closing our cursor
// and returning our array list.
cursorCourses.close()
return courseModalArrayList
}
}
Step 4: Create a new Activity to view data.
Navigate to app > kotlin+java > {package-name}, Right click on it, New > Empty Views Activity, name it as ViewCourses and uncheck the Generate Layout file option. Now add below code to it. Comments are added in the code to get to know in detail. In this file, we will create a composable function that contains a lazy column and 4 texts inside the each item of the lazy column to display a list of courses.
ViewCourses.kt:
Kotlin
package com.geeksforgeeks.demo
import android.content.Context
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
class ViewCourses : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme {
ReadDataFromDatabase(LocalContext.current)
}
}
}
}
@Composable
fun ReadDataFromDatabase(context: Context) {
// initialize array list
val courseList: List<CourseModal>
val dbHandler = DBHandler(context)
courseList = dbHandler.readCourses()
// create a lazy column for displaying a list view.
LazyColumn {
// set data for each item of listview
itemsIndexed(courseList) { index, _ ->
// create card for each item
Card(
modifier = Modifier.padding(8.dp),
elevation = CardDefaults.cardElevation(6.dp)
) {
Column(
modifier = Modifier.padding(8.dp).fillMaxWidth(),
horizontalAlignment = Alignment.Start,
verticalArrangement = Arrangement.Center
) {
Text(
text = courseList[index].courseName,
modifier = Modifier.padding(4.dp),
color = Color.Black, textAlign = TextAlign.Center
)
Spacer(modifier = Modifier.width(5.dp))
Text(
text = "Course Tracks : " + courseList[index].courseTracks,
modifier = Modifier.padding(4.dp),
color = Color.Black, textAlign = TextAlign.Center
)
Spacer(modifier = Modifier.width(5.dp))
Text(
text = "Course Duration : " + courseList[index].courseDuration,
modifier = Modifier.padding(4.dp),
color = Color.Black, textAlign = TextAlign.Center
)
Spacer(modifier = Modifier.width(5.dp))
Text(
text = "Description : " + courseList[index].courseDescription,
modifier = Modifier.padding(4.dp),
color = Color.Black, textAlign = TextAlign.Center
)
}
}
}
}
}
Step 5: Working with MainActivity.kt
In this step, we will add an extra button to the MainActivity file to navigate to the view courses screen.
MainActivity.kt:
Kotlin
package com.geeksforgeeks.demo
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme {
val context = LocalContext.current
AddDataToDatabase(context)
}
}
}
}
@Composable
fun AddDataToDatabase(
context: Context
) {
// variables for text field
val courseName = remember {
mutableStateOf(TextFieldValue())
}
val courseDuration = remember {
mutableStateOf(TextFieldValue())
}
val courseTracks = remember {
mutableStateOf(TextFieldValue())
}
val courseDescription = remember {
mutableStateOf(TextFieldValue())
}
// column for displaying text fields
Column(
modifier = Modifier
.fillMaxSize()
.padding(all = 30.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
) {
// initialize database handler
val dbHandler: DBHandler = DBHandler(context)
Text(
text = "SQLite Database in Android",
color = Color.Black, fontSize = 20.sp, fontWeight = FontWeight.Bold
)
Spacer(modifier = Modifier.height(20.dp))
// text field for course name
TextField(
value = courseName.value,
onValueChange = { courseName.value = it },
placeholder = { Text(text = "Enter your course name") },
modifier = Modifier
.fillMaxWidth(),
textStyle = TextStyle(color = Color.Black, fontSize = 15.sp),
singleLine = true,
)
Spacer(modifier = Modifier.height(20.dp))
// text field for course duration
TextField(
value = courseDuration.value,
onValueChange = { courseDuration.value = it },
placeholder = { Text(text = "Enter your course duration") },
modifier = Modifier
.fillMaxWidth(),
textStyle = TextStyle(color = Color.Black, fontSize = 15.sp),
singleLine = true,
)
Spacer(modifier = Modifier.height(20.dp))
// text field for course tracks
TextField(
value = courseTracks.value,
onValueChange = { courseTracks.value = it },
placeholder = { Text(text = "Enter your course tracks") },
modifier = Modifier
.fillMaxWidth(),
textStyle = TextStyle(color = Color.Black, fontSize = 15.sp),
singleLine = true,
)
Spacer(modifier = Modifier.height(20.dp))
// text field for course description
TextField(
value = courseDescription.value,
onValueChange = { courseDescription.value = it },
placeholder = { Text(text = "Enter your course description") },
modifier = Modifier
.fillMaxWidth(),
textStyle = TextStyle(color = Color.Black, fontSize = 15.sp),
singleLine = true,
)
Spacer(modifier = Modifier.height(15.dp))
// button to add a new course
Button(onClick = {
// call function to add new course
dbHandler.addNewCourse(
courseName.value.text,
courseDuration.value.text,
courseDescription.value.text,
courseTracks.value.text
)
Toast.makeText(context, "Course Added to Database", Toast.LENGTH_SHORT).show()
}) {
Text(text = "Add Course to Database", color = Color.White)
}
Spacer(modifier = Modifier.height(15.dp))
// button to open courses list screen
Button(onClick = {
val i = Intent(context, ViewCourses::class.java)
context.startActivity(i)
}) {
Text(text = "Read Courses to Database", color = Color.White)
}
}
}
Output:
Similar Reads
How to Delete Data in SQLite Database in Android using Jetpack Compose?
In the previous articles, we have seen three operations of CRUD operations such as create, read and update operations in our Android app. In this article, we will take a look at the delete operation for deleting our items stored in the SQLite database in the android application using Jetpack Compose
11 min read
How to Update Data to SQLite Database in Android using Jetpack Compose?
We have seen How to Create and Add Data to SQLite Database in Android using Jetpack Compose as well as How to Read Data from SQLite Database in Android using Jetpack Compose. We have performed different SQL queries for reading and writing our data to SQLite database. In this article, we will take a
11 min read
How to Create and Add Data to SQLite Database in Android using Jetpack Compose?
SQLite Database is another data storage available in Android where we can store data in the user’s device and can use it any time when required. In this article we will take a look on How to Create and add data to SQLite Database in Android using Jetpack Compose. Step by Step ImplementationStep 1: C
6 min read
How to Read Data from SQLite Database in Android?
In the 1st part of our SQLite database, we have seen How to Create and Add Data to SQLite Database in Android. In that article, we have added data to our SQLite Database. In this article, we will read all this data from the SQLite database and display this data in RecyclerView. What we are going to
12 min read
How to pre populate database in Android using SQLite Database
Introduction : Often, there is a need to initiate an Android app with an already existing database. This is called prepopulating a database. In this article, we will see how to pre-populate database in Android using SQLite Database. The database used in this example can be downloaded as Demo Databas
7 min read
Android Jetpack Compose - Add Data to Firebase Realtime Database
Firebase Realtime Database provides us with a feature to give Real-time updates to your data inside your app within milliseconds. With the help of Firebase, you can provide Real-time updates to your users. In this article, we will take a look at How to add data to Firebase Realtime Database in Andro
10 min read
How to Disable Text Selection in Android using Jetpack Compose?
In Android, a TextView is used to display text inside the activity on the screen. Similarly, in Jetpack Compose, a Text element is used to display text on the activity screen. By default, the text displayed in the Text element cannot be selected. To do so, the Text element has to be declared inside
3 min read
How to Read Data from Realm Database in Android?
In the previous article, we have seen adding data to the realm database in Android. In this article, we will take a look at reading this data from our Realm Database in the Android app. What we are going to build in this article? In this article, we will be simply adding a Button to open a new act
8 min read
How to Get Current Time and Date in Android using Jetpack Compose?
Many times in android applications we have to capture the current date and time within our android application so that we can update our data according to that. In this article, we will look at How to get the Current Time and Date in our android application using Jetpack Compose. Step by Step Imple
4 min read
Android Jetpack Compose - Retrieve Data From the Firebase Realtime Database
Firebase Realtime Database is the backend service that is provided by Google for handling backend tasks for your Android apps, IOS apps as well as websites. It provides so many services such as storage, database, and many more. The feature for which Firebase is famous is its Firebase Realtime Databa
8 min read