How to set up a SQLite database in Android Studio

Are you an Android Studio developer looking to add database functionality to your app? Look no further than SQLite! In this article, we’ll go over how to set up a SQLite database in Android Studio and how to use it effectively. We’ll also touch on some common pitfalls and best practices to help you avoid any potential issues.

Table of Contents

Introduction

SQLite is a lightweight, fast, and reliable relational database system that is widely used in mobile app development. It allows you to store and retrieve data efficiently, without the need for an internet connection.

Creating the Database

Before we dive into the code, let’s first discuss how to create a SQLite database in Android Studio. To do this, follow these steps:

Open your Android Studio project.
Go to the `app` module in the `build.gradle` file (or click on the `app` module in the Project Explorer).
In the `build.gradle` file, add the following dependency to your `dependencies` block:

groovy
implementation ‘androidx.room:room-runtime:2.3.0’

Next, create a new file called `DatabaseHelper.kt`. This file will contain our database helper class that we’ll use throughout our app to interact with the database.
In this file, add the following code:

kotlin
import androidx.room.Database
import androidx.room.RoomDatabase
@Database(entities = [YourEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
abstract fun yourDao(): YourDao
}

Now, create a new file called `YourEntity.kt`. This file will contain the definition of our SQLite table.
In this file, add the following code:

kotlin
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = “your_table_name”)
data class YourEntity(
@PrimaryKey(autoGenerate = true) val id: Int,
val name: String,
val age: Int
)

Finally, create a new file called `YourDao.kt`. This file will contain the DAO (Data Access Object) interface for our database.
In this file, add the following code:

kotlin
import androidx.lifecycle.LiveData
import androidx.room.*
@Dao
interface YourDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertAll(yourEntity: YourEntity)
@Query(“SELECT * FROM your_table_name”)
fun getAll(): LiveData<List>
}

Using the Database

Now that we have our database set up, let’s see how we can use it effectively in our app. To do this, follow these steps:

In your main activity or any other activity where you want to interact with the database, add the following dependency to your `build.gradle` file (or click on the `app` module in the Project Explorer):

groovy
implementation ‘androidx.room:room-runtime:2.3.0’

Note: This will add the Room library to your activity and allow you to interact with the database.

Inject the `DatabaseHelper` class into your activity by adding the following code to your `MainActivity.kt` file (or replace it with the name of your activity):

kotlin
import androidx.lifecycle.Observer
import androidx.room.*
class MainActivity : AppCompatActivity() {
private lateinit var db: AppDatabase
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
db = Room.databaseBuilder(applicationContext, AppDatabase::class.java, “my-db”).build()
}
fun saveDataToDatabase() {
val yourEntity = YourEntity(name = “John Doe”, age = 30)
db.yourDao().insertAll(yourEntity)
}
fun getDataFromDatabase() {
db.yourDao().getAll().observe(this, Observer { yourEntities ->
// do something with the data
println(“All your entities: $yourEntities”)
})
}
}

Use the methods we defined in the DAO interface to interact with your SQLite table. For example, to insert a new row into the table, call `saveDataToDatabase()` and pass in an instance of `YourEntity`. To retrieve all rows from the table, call `getDataFromDatabase()`.

Note: You can also use Room’s built-in support for transactions to ensure that multiple database operations are performed atomically. For example, you can wrap your data access code in a transaction like this:

kotlin
db.