Below are all steps covered in this blog

How to use the Room database
How to add Room Database in android studio
Insert,Update,Delete record
How to pass query in Database

What is a Room?

The Room strong library provides an abstraction layer over SQLite to allow for more robust database access while harnessing the full power of SQLite.
Normally Room databases are fast created and have good performance like reading, updating and deleting records. Room Database makes everything easy and fast
Room Database more detail open this link: https://developer.android.com/training/data-storage/room/

Components of Room Here room have main 3 components

Entity:

Instead of creating the SQLite table, we will create the Entity. An entity is nothing but a model class annotated with @Entity. The variables of this class are our columns, and the class is our table.

Database:

It is an abstract class where we define all our entities.

DAO:

Stands for Data Access Objects. It is an interface that defines all the operations that we need to perform in our database.

Demo App Create

First, we create a new project in android studio.
Name of my project "Room DataBase"

Adding Dependencies

Add needed dependencies for the room database.
Android studio in this file add dependencies "build.gradle".
See the below image and add the latest version room database replace here "$room_version" add original version

First, we will create DAO class:

This DAO class-main work intermediary between the user and database. All performed operations are defined here.
Below create StudentDao class

@Dao
public interface StudentDao {

@Query("SELECT * FROM Student")
List<Student> getAll();

@Insert
void insert(Student student);

@Update
void updateTask(Student student);

@Delete
void deleteTask(Student student);
}

Nowhere explain all components of StudentDao Class

Compulsory add class upper "@Dao" keyword
Three methods create insert, update, delete
Most important thing here is "@Query"

What is a Query?

Using query to get database existing record.
@Query("SELECT * FROM Student") this query gets all student records.
But the user wants to get only the standard "5" student record and only get how to pass a query?

    @Query("SELECT * FROM STUDENT where std = :std")

    List<Student> dataCheck(String std);

Here "std" id table field name
Call this method "data check(String std)" pass a string in "5" and database in getting only 5 stander student record
So this concept use the query parameter

Second steps create student model class

@Entity(tableName = "student")
public class Student implements Serializable {

@PrimaryKey(autoGenerate  = true)
private int id;

@ColumnInfo(name = "std")
private int std;

@ColumnInfo(name = "name")
private String name;

public int getId() {
    return id;
  }

public void setId(int id) {
    this.id = id;
  }

public int getStd() {
    return std;
  }

public void setStd(int std) {
    this.std = std;
  }

public String getName() {
    return name;
  }

public void setName(String name) {
    this.name = name;
  }
}

PrimaryKey: auto increment values
tableName : user wants to set the table name
ColumnInfo: give the table in columns name

Third steps Create Database class:

@Database(entities = {Student.class}, version = 1)
public abstract class AppDatabase extends     RoomDatabase {
public abstract Student studentDao();
}

User wants to add multiple tables how can add like that:

@Database(entities = {Student.class,Abc.class,Xyz.class}, version = 1) public abstract class AppDatabase extends RoomDatabase { public abstract Student studentDao(); }

To create a new model class like Abc.class and Xyz.class etc same method.

Fourth step inserts, update and delete records create separate method:

But implements upper all method in understanding asynctask
You, not knowing whats is asynctask first open this link and check it: https://developer.android.com/reference/android/os/AsyncTask
how we will create a common class method insert,update, delete

 public class InsertUpdateDeletRecord {

    private String DB_NAME = "db_task";

    private Student Student;
    public studentRepository(Context context) {
        Student = Room.databaseBuilder(context, Student.class, DB_NAME).build();
    }

    public void insertTask(String std,String name) {

        insertTask(std, name);
    }

    public void insertTask(String std,String name) {
        Student student = new Student();
        student.setstd(std);
        student.setname(name);

        insertTask(student);
    }

    public void insertTask(final Student student) {
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... voids) {
                Student.daoAccess().insertTask(student);
                return null;
            }
        }.execute();
    }

    public void updateTask(final Student student) {
        student.setModifiedAt(AppUtils.getCurrentDateTime());

        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... voids) {
                Student.daoAccess().updateTask(student);
                return null;
            }
        }.execute();
    }

    public void deleteTask(final int id) {
        final LiveData<student> task = getTask(id);
        if(task != null) {
            new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(Void... voids) {
                    Student.daoAccess().deleteTask(task.getValue());
                    return null;
                }
            }.execute();
        }
    }

    public void deleteTask(final student student) {
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... voids) {
                Student.daoAccess().deleteTask(student);
                return null;
            }
        }.execute();
    }

 }

Sample Implementation of basic CRUD operations using ROOM

Insert:

 InsertUpdateDeletRecord 
 insertUpdateDeletRecord = new 
 InsertUpdateDeletRecord(getApplicationContext( ));
 String std = "5";
 String name = Android";
 insertUpdateDeletRecord.insertTask(title, 
 description);

Update:

 InsertUpdateDeletRecord 
 insertUpdateDeletRecord = new 
 InsertUpdateDeletRecord(getApplicationContext( ));
 Student student = 
 insertUpdateDeletRecord.getTask(2);
 student.setName("Java");
 student.setStd("6");
 insertUpdateDeletRecord.updateTask(student);

Update:

 InsertUpdateDeletRecord 
 insertUpdateDeletRecord = new 
 InsertUpdateDeletRecord(getApplicationContext());
 insertUpdateDeletRecord.deleteTask(3);

Custom GPT Builder

Build a Custom ChatGPT Bot trained for your Website Content.