Upload a Local Database to an Online Database Android Studio

Save data in a local database using Room Office of Android Jetpack.

Apps that handle not-fiddling amounts of structured data can do good greatly from persisting that data locally. The about common utilize example is to enshroud relevant pieces of data then that when the device cannot access the network, the user can nevertheless browse that content while they are offline.

The Room persistence library provides an brainchild layer over SQLite to allow fluent database access while harnessing the total power of SQLite. In particular, Room provides the following benefits:

• Compile-time verification of SQL queries.
• Convenience annotations that minimize repetitive and error-prone boilerplate code.
• Streamlined database migration paths.

Because of these considerations, we highly recommend that you use Room instead of using the SQLite APIs directly.

Setup

To apply Room in your app, add the post-obit dependencies to your app's build.gradle file:

Groovy

dependencies {     def room_version = "ii.iv.2"      implementation "androidx.room:room-runtime:$room_version"     annotationProcessor "androidx.room:room-compiler:$room_version"      // optional - RxJava2 support for Room     implementation "androidx.room:room-rxjava2:$room_version"      // optional - RxJava3 support for Room     implementation "androidx.room:room-rxjava3:$room_version"      // optional - Guava support for Room, including Optional and ListenableFuture     implementation "androidx.room:room-guava:$room_version"      // optional - Exam helpers     testImplementation "androidx.room:room-testing:$room_version"      // optional - Paging 3 Integration     implementation "androidx.room:room-paging:two.5.0-alpha01" }            

Kotlin

dependencies {     val roomVersion = "two.four.two"      implementation("androidx.room:room-runtime:$roomVersion")     annotationProcessor("androidx.room:room-compiler:$roomVersion")      // To use Kotlin annotation processing tool (kapt)     kapt("androidx.room:room-compiler:$roomVersion")     // To utilize Kotlin Symbolic Processing (KSP)     ksp("androidx.room:room-compiler:$roomVersion")      // optional - Kotlin Extensions and Coroutines back up for Room     implementation("androidx.room:room-ktx:$roomVersion")      // optional - RxJava2 support for Room     implementation("androidx.room:room-rxjava2:$roomVersion")      // optional - RxJava3 support for Room     implementation("androidx.room:room-rxjava3:$roomVersion")      // optional - Guava support for Room, including Optional and ListenableFuture     implementation("androidx.room:room-guava:$roomVersion")      // optional - Test helpers     testImplementation("androidx.room:room-testing:$roomVersion")      // optional - Paging 3 Integration     implementation("androidx.room:room-paging:2.5.0-alpha01") }            

Primary components

There are three major components in Room:

• The database grade that holds the database and serves as the main access bespeak for the underlying connection to your app's persisted information.
• Data entities that represent tables in your app's database.
• Data admission objects (DAOs) that provide methods that your app can use to query, update, insert, and delete data in the database.

The database class provides your app with instances of the DAOs associated with that database. In turn, the app can apply the DAOs to remember information from the database as instances of the associated data entity objects. The app can also utilise the defined data entities to update rows from the respective tables, or to create new rows for insertion. Figure 1 illustrates the relationship betwixt the dissimilar components of Room.

Effigy one. Diagram of Room library compages.

Sample implementation

This department presents an example implementation of a Room database with a single data entity and a unmarried DAO.

Information entity

The following lawmaking defines a User data entity. Each example of User represents a row in a user table in the app'south database.

Kotlin

@Entity data class User(     @PrimaryKey val uid: Int,     @ColumnInfo(proper noun = "first_name") val firstName: String?,     @ColumnInfo(name = "last_name") val lastName: String? )            

Java

@Entity public class User {     @PrimaryKey     public int uid;      @ColumnInfo(name = "first_name")     public Cord firstName;      @ColumnInfo(name = "last_name")     public String lastName; }            

To learn more about data entities in Room, see Defining data using Room entities.

Information admission object (DAO)

The following code defines a DAO chosen UserDao. UserDao provides the methods that the residuum of the app uses to collaborate with data in the user table.

Kotlin

@Dao interface UserDao {     @Query("SELECT * FROM user")     fun getAll(): List<User>      @Query("SELECT * FROM user WHERE uid IN (:userIds)")     fun loadAllByIds(userIds: IntArray): List<User>      @Query("SELECT * FROM user WHERE first_name LIKE :first AND " +            "last_name LIKE :last LIMIT 1")     fun findByName(first: String, last: Cord): User      @Insert     fun insertAll(vararg users: User)      @Delete     fun delete(user: User) }            

Java

@Dao public interface UserDao {     @Query("SELECT * FROM user")     List<User> getAll();      @Query("SELECT * FROM user WHERE uid IN (:userIds)")     Listing<User> loadAllByIds(int[] userIds);      @Query("SELECT * FROM user WHERE first_name Similar :beginning AND " +            "last_name Similar :final LIMIT one")     User findByName(String first, String last);      @Insert     void insertAll(User... users);      @Delete     void delete(User user); }            

To learn more most DAOs, run into Accessing information using Room DAOs.

Database

The following code defines an AppDatabase class to hold the database. AppDatabase defines the database configuration and serves as the app's master access point to the persisted data. The database grade must satisfy the post-obit conditions:

• The grade must exist annotated with a @Database annotation that includes an entities assortment that lists all of the data entities associated with the database.
• The class must be an abstract class that extends RoomDatabase.
• For each DAO form that is associated with the database, the database class must define an abstract method that has zero arguments and returns an case of the DAO class.

Kotlin

@Database(entities = [User::class], version = 1) abstract class AppDatabase : RoomDatabase() {     abstract fun userDao(): UserDao }            

Java

@Database(entities = {User.class}, version = one) public abstract grade AppDatabase extends RoomDatabase {     public abstract UserDao userDao(); }            

Note: If your app runs in a single process, you should follow the singleton design design when instantiating an AppDatabase object. Each RoomDatabase instance is fairly expensive, and yous rarely need admission to multiple instances within a single process.

If your app runs in multiple processes, include enableMultiInstanceInvalidation() in your database builder invocation. That way, when you have an instance of AppDatabase in each process, you can invalidate the shared database file in one procedure, and this invalidation automatically propagates to the instances of AppDatabase within other processes.

Usage

Subsequently you have defined the data entity, the DAO, and the database object, you tin can use the following code to create an instance of the database:

Kotlin

val db = Room.databaseBuilder(             applicationContext,             AppDatabase::class.java, "database-proper noun"         ).build()            

Java

AppDatabase db = Room.databaseBuilder(getApplicationContext(),         AppDatabase.class, "database-proper name").build();            

You tin then use the abstruse methods from the AppDatabase to become an instance of the DAO. In plough, y'all tin use the methods from the DAO instance to collaborate with the database:

Kotlin

val userDao = db.userDao() val users: List<User> = userDao.getAll()            

Java

UserDao userDao = db.userDao(); List<User> users = userDao.getAll();            

Additional resources

To learn more than near Room, run across the following additional resources:

Sample

• Android Sunflower, a gardening app that illustrates Android evolution best practices with Android Jetpack.
• Tivi, a TV show tracking app that uses the latest libraries and tools.

Codelabs

• Android Room with a View (Java) (Kotlin)

Blogs

• 7 Pro-tips for Room
• Incrementally drift from SQLite to Room

myrickbrociall.blogspot.com

Source: https://developer.android.com/training/data-storage/room