Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

ตั้งค่าฐานข้อมูล Room สำหรับ KMP

ไลบรารี Room Persistence มีเลเยอร์การแยกส่วนเหนือ SQLite เพื่อให้เข้าถึงฐานข้อมูลได้อย่างมีประสิทธิภาพมากขึ้นพร้อมกับใช้ประโยชน์จากความสามารถทั้งหมดของ SQLite หน้านี้เน้นการใช้ Room ในโปรเจ็กต์ Kotlin Multiplatform (KMP) ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Room ได้ที่ บันทึกข้อมูลในฐานข้อมูลของเครื่องโดยใช้ Room หรือ ตัวอย่างอย่างเป็นทางการ

ตั้งค่าทรัพยากร Dependency

หากต้องการตั้งค่า Room ในโปรเจ็กต์ KMP ให้เพิ่มทรัพยากร Dependency สำหรับอาร์ติแฟกต์ในไฟล์ build.gradle.kts ของโมดูล KMP

กำหนดทรัพยากร Dependency ในไฟล์ libs.versions.toml ดังนี้

[versions]
room3 = "3.0.1"
sqlite = "2.7.0"
ksp = "<kotlinCompatibleKspVersion>"

[libraries]
androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqlite" }
androidx-room3-runtime = { module = "androidx.room3:room3-runtime", version.ref = "room3" }
androidx-room3-compiler = { module = "androidx.room3:room3-compiler", version.ref = "room3" }

# Optional SQLite Wrapper
androidx-room3-sqlite-wrapper = { module = "androidx.room3:room3-sqlite-wrapper", version.ref = "room3" }

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
androidx-room3 = { id = "androidx.room3", version.ref = "room3" }

เพิ่มปลั๊กอิน Room Gradle เพื่อกำหนดค่าสคีมา Room และปลั๊กอิน KSP

plugins {
  alias(libs.plugins.ksp)
  alias(libs.plugins.androidx.room3)
}

เพิ่มทรัพยากร Dependency รันไทม์ของ Room และไลบรารี SQLite ที่รวมไว้

commonMain.dependencies {
  implementation(libs.androidx.room3.runtime)
  implementation(libs.androidx.sqlite.bundled)
}

// Optional when using Room SQLite Wrapper
androidMain.dependencies {
  implementation(libs.androidx.room3.sqlite.wrapper)
}

เพิ่มทรัพยากร Dependency ของ KSP ลงในบล็อก dependencies ระดับราก คุณต้องเพิ่มเป้าหมายทั้งหมดที่แอปใช้ ดูข้อมูลเพิ่มเติมได้ที่ KSP with Kotlin Multiplatform

dependencies {
    add("kspAndroid", libs.androidx.room3.compiler)
    add("kspIosSimulatorArm64", libs.androidx.room3.compiler)
    add("kspIosX64", libs.androidx.room3.compiler)
    add("kspIosArm64", libs.androidx.room3.compiler)
    // Add any other platform target you use in your project, for example kspDesktop
}

กำหนดไดเรกทอรีสคีมา Room ดูข้อมูลเพิ่มเติมได้ที่ตั้งค่าตำแหน่งสคีมา โดยใช้ปลั๊กอิน Room Gradle

room {
    schemaDirectory("$projectDir/schemas")
}

กำหนดคลาสฐานข้อมูล

คุณต้องสร้างคลาสฐานข้อมูลที่มีคำอธิบายประกอบด้วย @Database พร้อมกับ DAO และเอนทิตีภายในชุดแหล่งที่มาทั่วไปของโมดูล KMP ที่แชร์ การวางคลาสเหล่านี้ในแหล่งที่มาทั่วไปจะช่วยให้แชร์คลาสเหล่านี้ในแพลตฟอร์มเป้าหมายทั้งหมดได้

// shared/src/commonMain/kotlin/Database.kt

@Database(entities = [TodoEntity::class], version = 1)
@ConstructedBy(AppDatabaseConstructor::class)
abstract class AppDatabase : RoomDatabase() {
  abstract fun getDao(): TodoDao
}

// The Room compiler generates the `actual` implementations.
@Suppress("KotlinNoActualForExpect")
expect object AppDatabaseConstructor : RoomDatabaseConstructor<AppDatabase> {
    override fun initialize(): AppDatabase
}

เมื่อคุณประกาศออบเจ็กต์ expect ด้วยอินเทอร์เฟซ RoomDatabaseConstructor คอมไพเลอร์ Room จะสร้างการติดตั้งใช้งาน actual Android Studio อาจแสดงคำเตือนต่อไปนี้ ซึ่งคุณสามารถ ระงับได้ด้วย @Suppress("KotlinNoActualForExpect")

Expected object 'AppDatabaseConstructor' has no actual declaration in module`

จากนั้นให้กำหนดอินเทอร์เฟซ DAO ใหม่ หรือย้ายอินเทอร์เฟซที่มีอยู่ไปยัง commonMain

// shared/src/commonMain/kotlin/TodoDao.kt

@Dao
interface TodoDao {
  @Insert
  suspend fun insert(item: TodoEntity)

  @Query("SELECT count(*) FROM TodoEntity")
  suspend fun count(): Int

  @Query("SELECT * FROM TodoEntity")
  fun getAllAsFlow(): Flow<List<TodoEntity>>
}

กำหนดหรือย้าย เอนทิตี ไปยัง commonMain

// shared/src/commonMain/kotlin/TodoEntity.kt

@Entity
data class TodoEntity(
  @PrimaryKey(autoGenerate = true) val id: Long = 0,
  val title: String,
  val content: String
)

สร้างตัวสร้างฐานข้อมูลเฉพาะแพลตฟอร์ม

คุณต้องกำหนดตัวสร้างฐานข้อมูลเพื่อสร้างอินสแตนซ์ Room ในแต่ละแพลตฟอร์ม นี่เป็นส่วนเดียวของ API ที่คุณต้องกำหนดในชุดแหล่งที่มาเฉพาะแพลตฟอร์ม เนื่องจาก API ระบบไฟล์มีความแตกต่างกัน

Android

ใน Android คุณมักจะรับตำแหน่งฐานข้อมูลโดยใช้ Context.getDatabasePath API หากต้องการสร้างอินสแตนซ์ฐานข้อมูล ให้ระบุ a Context และเส้นทางฐานข้อมูล

// shared/src/androidMain/kotlin/Database.android.kt

fun getDatabaseBuilder(context: Context): RoomDatabase.Builder<AppDatabase> {
  val appContext = context.applicationContext
  val dbFile = appContext.getDatabasePath("my_room.db")
  return Room.databaseBuilder<AppDatabase>(
    context = appContext,
    name = dbFile.absolutePath
  )
}

iOS

หากต้องการสร้างอินสแตนซ์ฐานข้อมูลใน iOS ให้ระบุเส้นทางฐานข้อมูลโดยใช้ NSFileManager ซึ่งมักจะอยู่ใน NSDocumentDirectory

// shared/src/iosMain/kotlin/Database.ios.kt

fun getDatabaseBuilder(): RoomDatabase.Builder<AppDatabase> {
    val dbFilePath = documentDirectory() + "/my_room.db"
    return Room.databaseBuilder<AppDatabase>(
        name = dbFilePath,
    )
}

private fun documentDirectory(): String {
  val documentDirectory = NSFileManager.defaultManager.URLForDirectory(
    directory = NSDocumentDirectory,
    inDomain = NSUserDomainMask,
    appropriateForURL = null,
    create = false,
    error = null,
  )
  return requireNotNull(documentDirectory?.path)
}

เดสก์ท็อป JVM

หากต้องการสร้างอินสแตนซ์ฐานข้อมูล ให้ระบุเส้นทางฐานข้อมูลโดยใช้ Java หรือ Kotlin API

// shared/src/jvmMain/kotlin/Database.desktop.kt

fun getDatabaseBuilder(): RoomDatabase.Builder<AppDatabase> {
    val dbFile = File(System.getProperty("java.io.tmpdir"), "my_room.db")
    return Room.databaseBuilder<AppDatabase>(
        name = dbFile.absolutePath,
    )
}

สร้างอินสแตนซ์ฐานข้อมูล

เมื่อได้รับ RoomDatabase.Builder จากตัวสร้างเฉพาะแพลตฟอร์มแล้ว คุณจะกำหนดค่าฐานข้อมูล Room ที่เหลือในโค้ดทั่วไปพร้อมกับการสร้างอินสแตนซ์ฐานข้อมูลจริงได้

// shared/src/commonMain/kotlin/Database.kt

fun getRoomDatabase(
    builder: RoomDatabase.Builder<AppDatabase>
): AppDatabase {
  return builder
      .setDriver(BundledSQLiteDriver())
      .setQueryCoroutineContext(Dispatchers.IO)
      .build()
}

เลือกไดรเวอร์ SQLite

ข้อมูลโค้ดก่อนหน้านี้เรียกใช้ฟังก์ชันตัวสร้าง setDriver เพื่อกำหนดไดรเวอร์ SQLite ที่ฐานข้อมูล Room ควรใช้ ไดรเวอร์เหล่านี้จะแตกต่างกันไปตามแพลตฟอร์มเป้าหมาย ข้อมูลโค้ดก่อนหน้านี้ใช้ BundledSQLiteDriver ซึ่งเป็นไดรเวอร์ที่แนะนำซึ่งรวมถึง SQLite ที่คอมไพล์จากแหล่งที่มา ซึ่งให้ SQLite เวอร์ชันที่สอดคล้องและเป็นปัจจุบันมากที่สุดในทุกแพลตฟอร์ม

หากต้องการใช้ SQLite ที่ระบบปฏิบัติการมีให้ ให้ใช้ API setDriver ในชุดแหล่งที่มาเฉพาะแพลตฟอร์มที่ระบุไดรเวอร์เฉพาะแพลตฟอร์ม ดู การติดตั้งใช้งานไดรเวอร์สำหรับคำอธิบายการติดตั้งใช้งานไดรเวอร์ที่มี คุณสามารถใช้อย่างใดอย่างหนึ่งต่อไปนี้

AndroidSQLiteDriver ใน androidMain
NativeSQLiteDriver ใน iosMain

หากต้องการใช้ NativeSQLiteDriver คุณต้องระบุตัวเลือก Linker -lsqlite3 เพื่อให้แอป iOS ลิงก์กับ SQLite ของระบบแบบไดนามิก

// shared/build.gradle.kts

kotlin {
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "TodoApp"
            isStatic = true
            // Required when using NativeSQLiteDriver
            linkerOpts.add("-lsqlite3")
        }
    }
}

ตั้งค่าบริบทโครูทีน

คุณสามารถกำหนดค่าออบเจ็กต์ RoomDatabase ใน Android ด้วยตัวดำเนินการแอปพลิเคชันที่แชร์โดยใช้ RoomDatabase.Builder.setQueryExecutor เพื่อดำเนินการฐานข้อมูล

เนื่องจากตัวดำเนินการไม่เข้ากันได้กับ KMP จึงไม่มี API setQueryExecutor ของ Room ใน commonMain แต่คุณต้องกำหนดค่าออบเจ็กต์ RoomDatabase ด้วย CoroutineContext ซึ่งคุณสามารถตั้งค่าได้โดยใช้ RoomDatabase.Builder.setCoroutineContext หากคุณไม่ได้ตั้งค่าบริบท ออบเจ็กต์ RoomDatabase จะใช้ Dispatchers.IO เป็นค่าเริ่มต้น

การลดขนาดและการทำให้โค้ดอ่านยาก

หากโปรเจ็กต์มีการลดขนาดหรือทำให้โค้ดอ่านยาก คุณต้องใส่ กฎ ProGuard ต่อไปนี้เพื่อให้ Room ค้นหาการติดตั้งใช้งานที่สร้างขึ้น ของคำจำกัดความฐานข้อมูลได้

-keep class * extends androidx.room3.RoomDatabase { <init>(); }

ย้ายข้อมูลไปยัง Kotlin Multiplatform

เดิมที Room ได้รับการพัฒนาเป็นไลบรารี Android และต่อมาย้ายข้อมูลไปยัง KMP โดยเน้นความเข้ากันได้ของ API Room เวอร์ชัน KMP จะแตกต่างกันเล็กน้อยระหว่างแพลตฟอร์มและจากเวอร์ชันเฉพาะ Android ความแตกต่างเหล่านี้แสดงและอธิบายไว้ดังนี้

ย้ายข้อมูลจาก Support SQLite ไปยัง SQLite Driver

การใช้งาน SupportSQLiteDatabase และ API อื่นๆ ใน androidx.sqlite.db ต้องได้รับการปรับโครงสร้างใหม่ด้วย SQLite Driver API เนื่องจาก API ใน androidx.sqlite.db ใช้ได้กับ Android เท่านั้น (โปรดทราบว่า แพ็กเกจแตกต่างจากแพ็กเกจ KMP)

เพื่อความเข้ากันได้แบบย้อนกลับและตราบใดที่กำหนดค่า RoomDatabase ด้วย SupportSQLiteOpenHelper.Factory (เช่น ไม่ได้ตั้งค่า SQLiteDriver) Room จะทำงานใน "โหมดความเข้ากันได้" ซึ่งทั้ง Support SQLite และ SQLite Driver API จะทำงานตามที่คาดไว้ ซึ่งจะช่วยให้การย้ายข้อมูลเป็นไปอย่างค่อยเป็นค่อยไป คุณจึงไม่จำเป็นต้องแปลงการใช้งาน Support SQLite ทั้งหมดเป็น SQLite Driver ในการเปลี่ยนแปลงครั้งเดียว

ใช้ Room SQLite Wrapper

อาร์ติแฟกต์ androidx.room3:room3-sqlite-wrapper มี API สำหรับเชื่อมโยงระหว่าง SQLiteDriver กับ SupportSQLiteDatabase ระหว่างการย้ายข้อมูล

หากต้องการรับ SupportSQLiteDatabase จาก RoomDatabase ที่กำหนดค่าด้วย SQLiteDriver ให้ใช้ฟังก์ชันส่วนขยายใหม่ RoomDatabase.getSupportWrapper Wrapper ความเข้ากันได้นี้ช่วยรักษา การใช้งาน SupportSQLiteDatabase ที่มีอยู่ ซึ่งคุณมักจะได้รับจาก RoomDatabase.openHelper.writableDatabase ขณะที่ใช้ SQLiteDriver, โดยเฉพาะอย่างยิ่งสำหรับฐานของโค้ดที่มีการใช้งาน SupportSQLite API อย่างกว้างขวางและต้องการ ใช้ BundledSQLiteDriver

แปลงคลาสย่อยของการย้ายข้อมูล

คลาสย่อยของการย้ายข้อมูลต้องย้ายข้อมูลไปยังส่วนที่เทียบเท่าของ SQLite Driver ดังนี้

Kotlin Multiplatform

คลาสย่อยของการย้ายข้อมูล

object Migration_1_2 : Migration(1, 2) {
  override fun migrate(connection: SQLiteConnection) {
    // …
  }
}

คลาสย่อยของการระบุการย้ายข้อมูลอัตโนมัติ

class AutoMigrationSpec_1_2 : AutoMigrationSpec {
  override fun onPostMigrate(connection: SQLiteConnection) {
    // …
  }
}

ใช้ได้กับ Android เท่านั้น

คลาสย่อยของการย้ายข้อมูล

object Migration_1_2 : Migration(1, 2) {
  override fun migrate(db: SupportSQLiteDatabase) {
    // …
  }
}

คลาสย่อยของการระบุการย้ายข้อมูลอัตโนมัติ

class AutoMigrationSpec_1_2 : AutoMigrationSpec {
  override fun onPostMigrate(db: SupportSQLiteDatabase) {
    // …
  }
}

แปลง Callback ฐานข้อมูล

Callback ฐานข้อมูลต้องย้ายข้อมูลไปยังส่วนที่เทียบเท่าของ SQLite Driver ดังนี้

Kotlin Multiplatform

object MyRoomCallback : RoomDatabase.Callback() {
  override fun onCreate(connection: SQLiteConnection) {
    // …
  }

  override fun onDestructiveMigration(connection: SQLiteConnection) {
    // …
  }

  override fun onOpen(connection: SQLiteConnection) {
    // …
  }
}

ใช้ได้กับ Android เท่านั้น

object MyRoomCallback : RoomDatabase.Callback() {
  override fun onCreate(db: SupportSQLiteDatabase) {
    // …
  }

  override fun onDestructiveMigration(db: SupportSQLiteDatabase) {
    // …
  }

  override fun onOpen(db: SupportSQLiteDatabase) {
    // …
  }
}

แปลงฟังก์ชัน DAO `@RawQuery`

ฟังก์ชันที่มีคำอธิบายประกอบด้วย @RawQuery ซึ่งคอมไพล์สำหรับแพลตฟอร์มที่ไม่ใช่ Android จะต้องประกาศพารามิเตอร์ประเภท RoomRawQuery แทน SupportSQLiteQuery

Kotlin Multiplatform

กำหนดการค้นหาแบบดิบ

@Dao
interface TodoDao {
  @RawQuery
  suspend fun getTodos(query: RoomRawQuery): List<TodoEntity>
}

จากนั้นคุณจะใช้ RoomRawQuery เพื่อสร้างการค้นหาในรันไทม์ได้ดังนี้

suspend fun AppDatabase.getTodosWithLowercaseTitle(title: String): List<TodoEntity> {
    val query = RoomRawQuery(
        sql = "SELECT * FROM TodoEntity WHERE title = ?",
        onBindStatement = {
            it.bindText(1, title.lowercase())
        }
    )

    return todoDao().getTodos(query)
}

ใช้ได้กับ Android เท่านั้น

กำหนดการค้นหาแบบดิบ

@Dao
interface TodoDao {
  @RawQuery
  suspend fun getTodos(query: SupportSQLiteQuery): List<TodoEntity>
}

จากนั้นคุณจะใช้ SimpleSQLiteQuery เพื่อสร้างการค้นหาในรันไทม์ได้ดังนี้

suspend fun AndroidOnlyDao.getTodosWithLowercaseTitle(title: String): List<TodoEntity> {
  val query = SimpleSQLiteQuery(
      query = "SELECT * FROM TodoEntity WHERE title = ?",
      bindArgs = arrayOf(title.lowercase())
  )
  return getTodos(query)
}

แปลงฟังก์ชัน DAO ที่บล็อก

Room ได้รับประโยชน์จากไลบรารี kotlinx.coroutines แบบอะซิงโครนัสที่เต็มไปด้วยฟีเจอร์ต่างๆ ซึ่ง Kotlin มีให้สำหรับหลายแพลตฟอร์ม เพื่อให้ฟังก์ชันการทำงานมีประสิทธิภาพสูงสุด ระบบจะบังคับใช้ฟังก์ชัน suspend สำหรับ DAO ที่คอมไพล์ในโปรเจ็กต์ KMP ยกเว้น DAO ที่ติดตั้งใช้งานใน androidMain เพื่อรักษาความเข้ากันได้แบบย้อนกลับกับฐานของโค้ดที่มีอยู่ เมื่อใช้ Room สำหรับ KMP ฟังก์ชัน DAO ทั้งหมดที่คอมไพล์สำหรับแพลตฟอร์มที่ไม่ใช่ Android ต้องเป็นฟังก์ชัน suspend

Kotlin Multiplatform

การค้นหาแบบระงับ

@Query("SELECT * FROM Todo")
suspend fun getAllTodos(): List<Todo>

ธุรกรรมแบบระงับ

@Transaction
suspend fun transaction() { … }

ใช้ได้กับ Android เท่านั้น

การค้นหาแบบบล็อก

@Query("SELECT * FROM Todo")
fun getAllTodos(): List<Todo>

ธุรกรรมแบบบล็อก

@Transaction
fun blockingTransaction() { … }

แปลงประเภท Reactive เป็น Flow

ฟังก์ชัน DAO บางฟังก์ชันไม่จำเป็นต้องเป็นฟังก์ชันระงับ ฟังก์ชัน DAO ที่แสดงผลประเภท Reactive เช่น LiveData หรือ Flowable ของ RxJava ไม่ควรแปลงเป็นฟังก์ชันระงับ อย่างไรก็ตาม บางประเภท เช่น LiveData ไม่เข้ากันได้กับ KMP ฟังก์ชัน DAO ที่มีประเภทการแสดงผล Reactive ต้องย้ายข้อมูลไปยัง Flow ของโครูทีน

Kotlin Multiplatform

ประเภท Reactive Flows

@Query("SELECT * FROM Todo")
fun getTodosFlow(): Flow<List<Todo>>

ใช้ได้กับ Android เท่านั้น

ประเภท Reactive เช่น LiveData หรือ Flowable ของ RxJava

@Query("SELECT * FROM Todo")
fun getTodosLiveData(): LiveData<List<Todo>>

แปลง API ธุรกรรม

API ธุรกรรมฐานข้อมูลสำหรับ Room KMP สามารถแยกความแตกต่างระหว่างธุรกรรมการเขียน (useWriterConnection) และการอ่าน (useReaderConnection)

Kotlin Multiplatform

val database: RoomDatabase = …
database.useWriterConnection { transactor ->
  transactor.immediateTransaction {
    // perform database operations in transaction
  }
}

ใช้ได้กับ Android เท่านั้น

val database: RoomDatabase = …
database.withTransaction {
  // perform database operations in transaction
}

ธุรกรรมการเขียน

ใช้ธุรกรรมการเขียนเพื่อให้แน่ใจว่าการค้นหาหลายรายการจะเขียนข้อมูลแบบอะตอมมิก เพื่อให้ผู้อ่านเข้าถึงข้อมูลได้อย่างสม่ำเสมอ คุณทำได้โดยใช้ useWriterConnection กับธุรกรรม 3 ประเภทต่อไปนี้

immediateTransaction: ในโหมด Write-Ahead Logging (WAL) (ค่าเริ่มต้น) ธุรกรรมประเภทนี้จะรับการล็อกเมื่อเริ่มต้น แต่ ผู้อ่านจะอ่านต่อได้ นี่เป็นตัวเลือกที่แนะนำสำหรับกรณีส่วนใหญ่
deferredTransaction: ธุรกรรมจะไม่รับการล็อกจนกว่าจะมีการเขียนคำสั่งแรก ใช้ธุรกรรมประเภทนี้เป็นการเพิ่มประสิทธิภาพเมื่อคุณไม่แน่ใจว่าจำเป็นต้องมีการดำเนินการเขียนภายในธุรกรรมหรือไม่ เช่น หากคุณเริ่มธุรกรรมเพื่อลบเพลงออกจากเพลย์ลิสต์โดยใช้เพียงชื่อเพลย์ลิสต์และเพลย์ลิสต์ไม่มีอยู่ ระบบก็ไม่จำเป็นต้องดำเนินการเขียน (ลบ)
exclusiveTransaction: โหมดนี้ทำงานเหมือนกับ immediateTransaction ในโหมด WAL ในโหมดบันทึกอื่นๆ จะป้องกันไม่ให้การเชื่อมต่อฐานข้อมูลอื่นๆ อ่านฐานข้อมูลขณะที่ธุรกรรมกำลังดำเนินการอยู่

ธุรกรรมการอ่าน

ใช้ธุรกรรมการอ่านเพื่ออ่านจากฐานข้อมูลหลายครั้งอย่างสม่ำเสมอ เช่น เมื่อคุณมีการค้นหาแยกกันอย่างน้อย 2 รายการและไม่ได้ใช้คําสั่ง JOIN อนุญาตให้ใช้เฉพาะธุรกรรมแบบเลื่อนเวลาในการเชื่อมต่อผู้อ่าน การพยายามเริ่มธุรกรรมแบบทันทีหรือแบบพิเศษในการเชื่อมต่อผู้อ่านจะส่งข้อยกเว้น เนื่องจากระบบถือว่าเป็นการดำเนินการ "เขียน"

val database: RoomDatabase = …
database.useReaderConnection { transactor ->
  transactor.deferredTransaction {
      // perform database operations in transaction
  }
}

ไม่พร้อมใช้งานใน Kotlin Multiplatform

API บางรายการที่พร้อมใช้งานสำหรับ Android ไม่พร้อมใช้งานใน Kotlin Multiplatform

Callback การค้นหา

API ต่อไปนี้สำหรับการกำหนดค่า Callback การค้นหาไม่พร้อมใช้งานในส่วนทั่วไป จึงไม่พร้อมใช้งานในแพลตฟอร์มอื่นที่ไม่ใช่ Android

RoomDatabase.Builder.setQueryCallback
RoomDatabase.QueryCallback

เราตั้งใจที่จะเพิ่มการรองรับ Callback การค้นหาใน Room เวอร์ชันอนาคต

API สำหรับกำหนดค่า RoomDatabase ด้วย Callback การค้นหา RoomDatabase.Builder.setQueryCallback พร้อมกับอินเทอร์เฟซ Callback RoomDatabase.QueryCallback ไม่พร้อมใช้งานในส่วนทั่วไป จึงไม่พร้อมใช้งาน ในแพลตฟอร์มอื่นที่ไม่ใช่ Android

ฐานข้อมูลปิดอัตโนมัติ

API สำหรับเปิดใช้การปิดอัตโนมัติหลังจากหมดเวลา RoomDatabase.Builder.setAutoCloseTimeout พร้อมใช้งานใน Android เท่านั้น และไม่พร้อมใช้งานในแพลตฟอร์มอื่นๆ

ฐานข้อมูลที่รวมไว้ล่วงหน้า

API ต่อไปนี้สำหรับการสร้าง RoomDatabase โดยใช้ฐานข้อมูลที่มีอยู่ (เช่น ฐานข้อมูลที่รวมไว้ล่วงหน้า) ไม่พร้อมใช้งานในส่วนทั่วไป จึงไม่พร้อมใช้งานในแพลตฟอร์มอื่นที่ไม่ใช่ Android API เหล่านี้ได้แก่

RoomDatabase.Builder.createFromAsset
RoomDatabase.Builder.createFromFile
RoomDatabase.Builder.createFromInputStream
RoomDatabase.PrepackagedDatabaseCallback

เราตั้งใจที่จะเพิ่มการรองรับฐานข้อมูลที่รวมไว้ล่วงหน้าใน Room เวอร์ชันอนาคต

การทำให้เป็นโมฆะในอินสแตนซ์หลายรายการ

API สำหรับเปิดใช้การทำให้เป็นโมฆะในอินสแตนซ์หลายรายการ RoomDatabase.Builder.enableMultiInstanceInvalidation พร้อมใช้งานใน Android เท่านั้น และไม่พร้อมใช้งานในส่วนทั่วไปหรือแพลตฟอร์มอื่นๆ

แนะนำสำหรับคุณ

หมายเหตุ: ข้อความลิงก์จะแสดงเมื่อ JavaScript ปิดอยู่
ย้ายข้อมูลแอปที่มีอยู่ไปยัง Codelab Room KMP
เริ่มต้นใช้งาน Codelab KMP
บันทึกข้อมูลในฐานข้อมูลของเครื่องด้วย Room

ตั้งค่าทรัพยากร Dependency

กำหนดคลาสฐานข้อมูล

สร้างตัวสร้างฐานข้อมูลเฉพาะแพลตฟอร์ม

Android

iOS

เดสก์ท็อป JVM

สร้างอินสแตนซ์ฐานข้อมูล

เลือกไดรเวอร์ SQLite

ตั้งค่าบริบทโครูทีน

การลดขนาดและการทำให้โค้ดอ่านยาก

ย้ายข้อมูลไปยัง Kotlin Multiplatform

ย้ายข้อมูลจาก Support SQLite ไปยัง SQLite Driver

ใช้ Room SQLite Wrapper

แปลงคลาสย่อยของการย้ายข้อมูล

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

แปลง Callback ฐานข้อมูล

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

แปลงฟังก์ชัน DAO @RawQuery

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

แปลงฟังก์ชัน DAO ที่บล็อก

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

แปลงประเภท Reactive เป็น Flow

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

แปลง API ธุรกรรม

Kotlin Multiplatform

ใช้ได้กับ Android เท่านั้น

ธุรกรรมการเขียน

ธุรกรรมการอ่าน

ไม่พร้อมใช้งานใน Kotlin Multiplatform

Callback การค้นหา

ฐานข้อมูลปิดอัตโนมัติ

ฐานข้อมูลที่รวมไว้ล่วงหน้า

การทำให้เป็นโมฆะในอินสแตนซ์หลายรายการ

แนะนำสำหรับคุณ

แปลงฟังก์ชัน DAO `@RawQuery`