SQLite (Kotlin मल्टीप्लैटफ़ॉर्म)

androidx.sqlite लाइब्रेरी में ऐब्स्ट्रैक्ट इंटरफ़ेस के साथ-साथ बुनियादी इस्तेमाल के उदाहरण भी शामिल होते हैं. इनका इस्तेमाल करके, ऐसी लाइब्रेरी बनाई जा सकती हैं जो SQLite को ऐक्सेस करती हैं. आपको Room लाइब्रेरी का इस्तेमाल करना चाहिए. यह SQLite को लेकर एक ऐब्स्ट्रैक्शन लेयर उपलब्ध कराती है, ताकि डेटाबेस को ज़्यादा अच्छे से ऐक्सेस किया जा सके.

डिपेंडेंसी सेट अप करना

अपने KMP प्रोजेक्ट में SQLite सेट अप करने के लिए, अपने मॉड्यूल की build.gradle.kts फ़ाइल में आर्टफ़ैक्ट के लिए डिपेंडेंसी जोड़ें:

[versions]
sqlite = "2.5.2"

[libraries]
# The SQLite Driver interfaces
androidx-sqlite = { module = "androidx.sqlite:sqlite", version.ref = "sqlite" }

# The bundled SQLite driver implementation
androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqlite" }

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

SQLite Driver API

androidx.sqlite लाइब्रेरी ग्रुप, SQLite लाइब्रेरी के साथ कम्यूनिकेट करने के लिए लो-लेवल एपीआई उपलब्ध कराते हैं. androidx.sqlite:sqlite-bundled का इस्तेमाल करते समय, लाइब्रेरी में शामिल SQLite लाइब्रेरी के साथ कम्यूनिकेट करने के लिए लो-लेवल एपीआई उपलब्ध कराए जाते हैं. वहीं, androidx.sqlite:sqlite-framework का इस्तेमाल करते समय, Android या iOS जैसे होस्ट प्लैटफ़ॉर्म में शामिल SQLite लाइब्रेरी के साथ कम्यूनिकेट करने के लिए लो-लेवल एपीआई उपलब्ध कराए जाते हैं. ये एपीआई, SQLite C API की मुख्य सुविधाओं के हिसाब से काम करते हैं.

इसके तीन मुख्य इंटरफ़ेस हैं:

• SQLiteDriver - यह SQLite का इस्तेमाल करने के लिए एंट्री पॉइंट है. साथ ही, यह डेटाबेस कनेक्शन खोलने के लिए ज़िम्मेदार है.
• SQLiteConnection - यह sqlite3 ऑब्जेक्ट को दिखाता है.
• SQLiteStatement - यह sqlite3_stmt ऑब्जेक्ट को दिखाता है.

यहां दिए गए उदाहरण में, मुख्य एपीआई दिखाए गए हैं:

fun main() {
  val databaseConnection = BundledSQLiteDriver().open("todos.db")
  databaseConnection.execSQL(
    "CREATE TABLE IF NOT EXISTS Todo (id INTEGER PRIMARY KEY, content TEXT)"
  )
  databaseConnection.prepare(
    "INSERT OR IGNORE INTO Todo (id, content) VALUES (? ,?)"
  ).use { stmt ->
    stmt.bindInt(index = 1, value = 1)
    stmt.bindText(index = 2, value = "Try Room in the KMP project.")
    stmt.step()
  }
  databaseConnection.prepare("SELECT content FROM Todo").use { stmt ->
    while (stmt.step()) {
      println("Action item: ${stmt.getText(0)}")
    }
  }
  databaseConnection.close()
}

SQLite C API की तरह ही, इसका इस्तेमाल इन कामों के लिए किया जाता है:

• इंस्टेंटिएट किए गए SQLiteDriver इस्तेमाल करके, डेटाबेस कनेक्शन खोलें.
• SQLiteConnection.prepare() का इस्तेमाल करके एसक्यूएल स्टेटमेंट तैयार करना
• SQLiteStatement को इस तरह से लागू करें:
  1. bind*() फ़ंक्शन का इस्तेमाल करके, आर्ग्युमेंट को बाइंड करें. हालांकि, ऐसा करना ज़रूरी नहीं है.
  2. step() फ़ंक्शन का इस्तेमाल करके, नतीजों के सेट पर बार-बार कार्रवाई करें.
  3. get*() फ़ंक्शन का इस्तेमाल करके, नतीजे के सेट से कॉलम पढ़ें.

ड्राइवर के लिए उपलब्ध सुविधाएं

इस टेबल में, ड्राइवर के लिए उपलब्ध सुविधाओं की खास जानकारी दी गई है:

इस्तेमाल करने के लिए, BundledSQLiteDriver को लागू करने का सुझाव दिया जाता है. यह androidx.sqlite:sqlite-bundled में उपलब्ध है. इसमें सोर्स से कंपाइल की गई SQLite लाइब्रेरी शामिल है. यह सभी KMP प्लैटफ़ॉर्म पर, सबसे नया वर्शन और एक जैसा अनुभव देती है.

SQLite ड्राइवर और Room

ड्राइवर एपीआई, SQLite डेटाबेस के साथ लो-लेवल इंटरैक्शन के लिए काम के होते हैं. अगर आपको ऐसी लाइब्रेरी चाहिए जिसमें कई सुविधाएं हों और SQLite को ज़्यादा अच्छे से ऐक्सेस किया जा सके, तो Room का इस्तेमाल करें.

डेटाबेस से जुड़ी कार्रवाइयां करने के लिए, RoomDatabase, SQLiteDriver पर निर्भर करता है. साथ ही, RoomDatabase.Builder.setDriver() का इस्तेमाल करके, इसे कॉन्फ़िगर करना ज़रूरी है. रूम, मैनेज किए गए डेटाबेस कनेक्शन को सीधे तौर पर ऐक्सेस करने के लिए RoomDatabase.useReaderConnection और RoomDatabase.useWriterConnection उपलब्ध कराता है.

Kotlin Multiplatform पर माइग्रेट करना

SQLite के निचले लेवल के सभी कॉल को, SQLite ड्राइवर के काउंटरपार्ट पर माइग्रेट करना होगा.

val connection: SQLiteConnection = ...
connection.execSQL("BEGIN IMMEDIATE TRANSACTION")
try {
  // perform database operations in transaction
  connection.execSQL("END TRANSACTION")
} catch(t: Throwable) {
  connection.execSQL("ROLLBACK TRANSACTION")
}

val connection: SQLiteConnection = ...
connection.execSQL("ALTER TABLE ...")

val connection: SQLiteConnection = ...
connection.prepare("SELECT * FROM Pet").use { statement ->
  while (statement.step()) {
    // read columns
    statement.getInt(0)
    statement.getText(1)
  }
}

connection.prepare("SELECT * FROM Pet WHERE id = ?").use { statement ->
  statement.bindInt(1, id)
  if (statement.step()) {
    // row found, read columns
  } else {
    // row not found
  }
}

val database: SupportSQLiteDatabase = ...
database.beginTransaction()
try {
  // perform database operations in transaction
  database.setTransactionSuccessful()
} finally {
  database.endTransaction()
}

val database: SupportSQLiteDatabase = ...
database.execSQL("ALTER TABLE ...")

val database: SupportSQLiteDatabase = ...
database.query("SELECT * FROM Pet").use { cursor ->
  while (cusor.moveToNext()) {
    // read columns
    cursor.getInt(0)
    cursor.getString(1)
  }
}

database.query("SELECT * FROM Pet WHERE id = ?", id).use { cursor ->
  if (cursor.moveToNext()) {
    // row found, read columns
  } else {
    // row not found
  }
}