แนวทางปฏิบัติแนะนำสำหรับประสิทธิภาพของ SQLite (มุมมอง)

แนวคิดและการใช้งาน Jetpack Compose

Android มีการรองรับ SQLite ในตัว ซึ่งเป็นฐานข้อมูล SQL ที่มีประสิทธิภาพ ทำตามแนวทางปฏิบัติแนะนำเหล่านี้เพื่อเพิ่มประสิทธิภาพของแอป เพื่อให้มั่นใจว่าแอปจะยังคงทำงานได้อย่างรวดเร็วและคาดการณ์ได้เมื่อข้อมูลเพิ่มขึ้น การใช้แนวทางปฏิบัติแนะนำเหล่านี้ยังช่วยลดโอกาสที่จะพบปัญหาด้านประสิทธิภาพที่จำลองและแก้ปัญหาได้ยากด้วย

โปรดทำตามหลักการด้านประสิทธิภาพต่อไปนี้เพื่อให้ทำงานได้เร็วขึ้น

  • อ่านแถวและคอลัมน์น้อยลง: เพิ่มประสิทธิภาพการค้นหาเพื่อดึงเฉพาะข้อมูลที่จำเป็น ลดปริมาณข้อมูลที่อ่านจากฐานข้อมูล เนื่องจาก การดึงข้อมูลมากเกินไปอาจส่งผลต่อประสิทธิภาพ

  • พุชงานไปยังเครื่องมือ SQLite: ทำการคำนวณ การกรอง และการจัดเรียงภายในคำสั่ง SQL การใช้เครื่องมือค้นหาของ SQLite จะช่วยปรับปรุงประสิทธิภาพได้อย่างมาก

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

นอกจากนี้ คุณยังใช้เครื่องมือแก้ปัญหาที่มีอยู่เพื่อวัดประสิทธิภาพของฐานข้อมูล SQLite เพื่อช่วยระบุส่วนที่ต้องเพิ่มประสิทธิภาพได้ด้วย

เราขอแนะนำให้ใช้ไลบรารี Jetpack Room

กำหนดค่าฐานข้อมูลเพื่อประสิทธิภาพ

ทำตามขั้นตอนในส่วนนี้เพื่อกำหนดค่าฐานข้อมูลให้มีประสิทธิภาพสูงสุดใน SQLite

ผ่อนคลายโหมดการซิงค์ข้อมูล

SQLite มีตัวเลือกในการควบคุมโหมดซิงโครนัส ในโหมด FULL ทุกๆ การคอมมิตจะออก fsync เพื่อช่วยให้มั่นใจว่าข้อมูลจะไปถึงดิสก์ ซึ่งจะช่วยปรับปรุงความคงทนของข้อมูล แต่จะทำให้การคอมมิตช้าลง เมื่อใช้ WAL โหมด NORMAL จะไม่ซิงค์ในทุกคอมมิตและยังคงปกป้องฐานข้อมูลจากความเสียหาย

เมื่อคุณเปิดใช้ WAL ผ่านเฟรมเวิร์ก Android จะใช้โหมดซิงโครนัส WAL เริ่มต้นของอุปกรณ์ ซึ่งก็คือ NORMAL ใน AOSP สำหรับ Android 9 ขึ้นไป ผู้ผลิตอุปกรณ์สามารถเปลี่ยนค่าเริ่มต้นนี้ได้ และฐานข้อมูลที่ไม่ได้ใช้ WAL จะมีค่าเริ่มต้นเป็น FULL หากต้องการตรวจสอบว่าฐานข้อมูลใช้ NORMAL ให้ตั้งค่าเมื่อคุณเปิดฐานข้อมูล ดังนี้

Kotlin

// When opening the database
val params = SQLiteDatabase.OpenParams.Builder()
    .addOpenFlags(SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
    // SYNC_MODE_NORMAL is available in API level 33 and higher.
    // On API levels 28 to 32, pass "NORMAL" instead.
    .setSynchronousMode(SQLiteDatabase.SYNC_MODE_NORMAL)
    .build()
// With SQLiteOpenHelper, call setOpenParams(params) in your constructor.

// Or: after having opened the database
db.execSQL("PRAGMA synchronous = NORMAL")

Java

// When opening the database
SQLiteDatabase.OpenParams params = new SQLiteDatabase.OpenParams.Builder()
    .addOpenFlags(SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
    // SYNC_MODE_NORMAL is available in API level 33 and higher.
    // On API levels 28 to 32, pass "NORMAL" instead.
    .setSynchronousMode(SQLiteDatabase.SYNC_MODE_NORMAL)
    .build();
// With SQLiteOpenHelper, call setOpenParams(params) in your constructor.

// Or: after having opened the database
db.execSQL("PRAGMA synchronous = NORMAL");

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

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

ปรับปรุงประสิทธิภาพการค้นหา

ทำตามแนวทางปฏิบัติแนะนำต่อไปนี้เพื่อปรับปรุงประสิทธิภาพการค้นหาใน SQLite โดยลดเวลาในการตอบสนองและเพิ่มประสิทธิภาพการประมวลผลให้สูงสุด

อ่านเฉพาะแถวที่ต้องการ

ตัวกรองช่วยให้คุณจำกัดผลการค้นหาให้แคบลงได้โดยระบุเกณฑ์บางอย่าง เช่น ช่วงวันที่ สถานที่ หรือชื่อ ขีดจำกัดช่วยให้คุณควบคุมจำนวนผลลัพธ์ที่เห็นได้ ดังนี้

Kotlin

db.rawQuery("""
    SELECT name
    FROM Customers
    LIMIT 10;
    """.trimIndent(),
    null
).use { cursor ->
    while (cursor.moveToNext()) {
        // Process cursor data
    }
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT name
    FROM Customers
    LIMIT 10;
    """, null)) {
  while (cursor.moveToNext()) {
    // Process cursor data
  }
}

อ่านเฉพาะคอลัมน์ที่ต้องการ

หลีกเลี่ยงการเลือกคอลัมน์ที่ไม่จำเป็น ซึ่งอาจทำให้การค้นหาช้าลงและสิ้นเปลืองทรัพยากร แต่ให้เลือกเฉพาะคอลัมน์ที่ใช้เท่านั้น

ในตัวอย่างต่อไปนี้ คุณเลือก id, name และ phone

Kotlin

// This is not the most efficient way of doing this.
// See the following example for a better approach.

db.rawQuery(
    """
    SELECT id, name, phone
    FROM customers;
    """.trimIndent(),
    null
).use { cursor ->
    while (cursor.moveToNext()) {
        val name = cursor.getString(1)
        // Further processing
    }
}

Java

// This is not the most efficient way of doing this.
// See the following example for a better approach.

try (Cursor cursor = db.rawQuery("""
    SELECT id, name, phone
    FROM customers;
    """, null)) {
  while (cursor.moveToNext()) {
    String name = cursor.getString(1);
    // Further processing
  }
}

อย่างไรก็ตาม คุณต้องมีคอลัมน์ name เท่านั้น

Kotlin

db.rawQuery("""
    SELECT name
    FROM Customers;
    """.trimIndent(),
    null
).use { cursor ->
    while (cursor.moveToNext()) {
        val name = cursor.getString(0)
        // Further processing
    }
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT name
    FROM Customers;
    """, null)) {
  while (cursor.moveToNext()) {
    String name = cursor.getString(0);
    // Further processing
  }
}

กำหนดพารามิเตอร์ให้คำค้นหา

สตริงคำค้นหาอาจมีพารามิเตอร์ที่ทราบเฉพาะที่รันไทม์ เช่น

Kotlin

fun getNameById(id: Long): String? {
    db.rawQuery(
        "SELECT name FROM customers WHERE id=$id", null
    ).use { cursor ->
        return if (cursor.moveToFirst()) {
            cursor.getString(0)
        } else {
            null
        }
    }
}

Java

@Nullable
public String getNameById(long id) {
  try (Cursor cursor = db.rawQuery(
      "SELECT name FROM customers WHERE id=" + id, null)) {
    if (cursor.moveToFirst()) {
      return cursor.getString(0);
    } else {
      return null;
    }
  }
}

ในโค้ดก่อนหน้า ทุกการค้นหาจะสร้างสตริงที่แตกต่างกัน จึงไม่ได้รับประโยชน์จากแคชคำสั่ง การเรียกแต่ละครั้งต้องใช้ SQLite เพื่อคอมไพล์ก่อนจึงจะดำเนินการได้ แต่คุณสามารถแทนที่อาร์กิวเมนต์ id ด้วยพารามิเตอร์และเชื่อมโยงค่ากับ selectionArgs แทนได้ ดังนี้

Kotlin

fun getNameById(id: Long): String? {
    db.rawQuery(
        """
          SELECT name
          FROM customers
          WHERE id=?
        """.trimIndent(), arrayOf(id.toString())
    ).use { cursor ->
        return if (cursor.moveToFirst()) {
            cursor.getString(0)
        } else {
            null
        }
    }
}

Java

@Nullable
public String getNameById(long id) {
  try (Cursor cursor = db.rawQuery("""
          SELECT name
          FROM customers
          WHERE id=?
      """, new String[] {String.valueOf(id)})) {
    if (cursor.moveToFirst()) {
      return cursor.getString(0);
    } else {
      return null;
    }
  }
}

ตอนนี้คุณสามารถคอมไพล์การค้นหาเพียงครั้งเดียวและแคชไว้ได้ ระบบจะนำการค้นหาที่คอมไพล์แล้วกลับมาใช้ซ้ำระหว่างการเรียกใช้ getNameById(long) ที่แตกต่างกัน

ใช้ DISTINCT สำหรับค่าที่ไม่ซ้ำกัน

การใช้คีย์เวิร์ด DISTINCT จะช่วยปรับปรุงประสิทธิภาพการค้นหาได้โดยการลดจำนวนข้อมูลที่ต้องประมวลผล เช่น หากต้องการแสดงเฉพาะค่าที่ไม่ซ้ำกันจากคอลัมน์ ให้ใช้ DISTINCT:

Kotlin

db.rawQuery("""
    SELECT DISTINCT name
    FROM Customers;
    """.trimIndent(),
    null
).use { cursor ->
    while (cursor.moveToNext()) {
        // Only iterate over distinct names in Kotlin
        // Process distinct name
    }
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT DISTINCT name
    FROM Customers;
    """, null)) {
  while (cursor.moveToNext()) {
    // Only iterate over distinct names in Java
    // Process distinct name
  }
}

ใช้ฟังก์ชันรวมข้อมูลเมื่อเป็นไปได้

ใช้ฟังก์ชันรวมข้อมูลสำหรับผลลัพธ์รวมโดยไม่มีข้อมูลแถว ตัวอย่างเช่น โค้ดต่อไปนี้จะตรวจสอบว่ามีแถวที่ตรงกันอย่างน้อย 1 แถวหรือไม่

Kotlin

// This is not the most efficient way of doing this.
// See the following example for a better approach.

db.rawQuery("""
    SELECT id, name
    FROM Customers
    WHERE city = 'Paris';
    """.trimIndent(),
    null
).use { cursor ->
    if (cursor.moveToFirst()) {
        // At least one customer from Paris
        // Handle found
    } else {
        // No customers from Paris
        // Handle not found
}

Java

// This is not the most efficient way of doing this.
// See the following example for a better approach.

try (Cursor cursor = db.rawQuery("""
    SELECT id, name
    FROM Customers
    WHERE city = 'Paris';
    """, null)) {
  if (cursor.moveToFirst()) {
    // At least one customer from Paris
    // Handle found
  } else {
    // No customers from Paris
    // Handle not found
  }
}

หากต้องการดึงข้อมูลเฉพาะแถวแรก คุณสามารถใช้ EXISTS() เพื่อแสดงผล 0 หากไม่มีแถวที่ตรงกัน และ 1 หากมีแถวที่ตรงกันอย่างน้อย 1 แถว

Kotlin

db.rawQuery("""
    SELECT EXISTS (
        SELECT null
        FROM Customers
        WHERE city = 'Paris';
    );
    """.trimIndent(),
    null
).use { cursor ->
    if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
        // At least one customer from Paris
        // Handle found
    } else {
        // No customers from Paris
        // Handle not found
    }
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT EXISTS (
      SELECT null
      FROM Customers
      WHERE city = 'Paris'
    );
    """, null)) {
  if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
    // At least one customer from Paris
    // Handle found
  } else {
    // No customers from Paris
    // Handle not found
  }
}

ใช้ฟังก์ชันรวมข้อมูล SQLite ในโค้ดของแอป ดังนี้

  • COUNT: นับจำนวนแถวในคอลัมน์
  • SUM: เพิ่มค่าตัวเลขทั้งหมดในคอลัมน์
  • MIN หรือ MAX: กำหนดค่าต่ำสุดหรือสูงสุด ใช้ได้กับคอลัมน์ตัวเลข ประเภท DATE และประเภทข้อความ
  • AVG: ค้นหาค่าตัวเลขเฉลี่ย
  • GROUP_CONCAT: เชื่อมโยงสตริงกับตัวคั่นที่ไม่บังคับ

ใช้ COUNT() แทน Cursor.getCount()

ในตัวอย่างต่อไปนี้ ฟังก์ชัน Cursor.getCount() จะอ่านแถวทั้งหมดจากฐานข้อมูลและแสดงผลค่าแถวทั้งหมด

Kotlin

// This is not the most efficient way of doing this.
// See the following example for a better approach.

db.rawQuery("""
    SELECT id
    FROM Customers;
    """.trimIndent(),
    null
).use { cursor ->
    val count = cursor.getCount()
    // Use count
}

Java

// This is not the most efficient way of doing this.
// See the following example for a better approach.

try (Cursor cursor = db.rawQuery("""
    SELECT id
    FROM Customers;
    """, null)) {
  int count = cursor.getCount();
  // Use count
}

อย่างไรก็ตาม เมื่อใช้ COUNT() ฐานข้อมูลจะแสดงผลเฉพาะจำนวนเท่านั้น

Kotlin

db.rawQuery("""
    SELECT COUNT(*)
    FROM Customers;
    """.trimIndent(),
    null
).use { cursor ->
    cursor.moveToFirst()
    val count = cursor.getInt(0)
    // Use count
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT COUNT(*)
    FROM Customers;
    """, null)) {
  cursor.moveToFirst();
  int count = cursor.getInt(0);
  // Use count
}

การค้นหา Nest แทนโค้ด

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

ในตัวอย่างต่อไปนี้ คุณสามารถเรียกใช้การค้นหาเพื่อดูว่าเมืองใดมีลูกค้ามากที่สุด จากนั้นใช้ผลลัพธ์ในการค้นหาอื่นเพื่อค้นหาลูกค้าทั้งหมดจากเมืองนั้น

Kotlin

// This is not the most efficient way of doing this.
// See the following example for a better approach.

db.rawQuery("""
    SELECT city
    FROM Customers
    GROUP BY city
    ORDER BY COUNT(*) DESC
    LIMIT 1;
    """.trimIndent(),
    null
).use { cursor ->
    if (cursor.moveToFirst()) {
        val topCity = cursor.getString(0)
        db.rawQuery("""
            SELECT name, city
            FROM Customers
            WHERE city = ?;
        """.trimIndent(),
        arrayOf(topCity)).use { innerCursor ->
            while (innerCursor.moveToNext()) {
                // Process inner cursor data
            }
        }
    }
}

Java

// This is not the most efficient way of doing this.
// See the following example for a better approach.

try (Cursor cursor = db.rawQuery("""
    SELECT city
    FROM Customers
    GROUP BY city
    ORDER BY COUNT(*) DESC
    LIMIT 1;
    """, null)) {
  if (cursor.moveToFirst()) {
    String topCity = cursor.getString(0);
    try (Cursor innerCursor = db.rawQuery("""
        SELECT name, city
        FROM Customers
        WHERE city = ?;
        """, new String[] {topCity})) {
        while (innerCursor.moveToNext()) {
          // Process inner cursor data
        }
    }
  }
}

หากต้องการได้ผลลัพธ์โดยใช้เวลาเพียงครึ่งหนึ่งของตัวอย่างก่อนหน้านี้ ให้ใช้การค้นหา SQL รายการเดียวที่มีคำสั่งที่ซ้อนกัน ดังนี้

Kotlin

db.rawQuery("""
    SELECT name, city
    FROM Customers
    WHERE city IN (
        SELECT city
        FROM Customers
        GROUP BY city
        ORDER BY COUNT (*) DESC
        LIMIT 1;
    );
    """.trimIndent(),
    null
).use { cursor ->
    if (cursor.moveToNext()) {
        // Process cursor data
    }
}

Java

try (Cursor cursor = db.rawQuery("""
    SELECT name, city
    FROM Customers
    WHERE city IN (
      SELECT city
      FROM Customers
      GROUP BY city
      ORDER BY COUNT(*) DESC
      LIMIT 1
    );
    """, null)) {
  while(cursor.moveToNext()) {
    // Process cursor data
  }
}

ตรวจสอบความไม่ซ้ำกันใน SQL

หากต้องไม่แทรกแถวเว้นแต่ค่าคอลัมน์หนึ่งๆ จะไม่ซ้ำกันในตาราง การบังคับใช้ความไม่ซ้ำกันนั้นเป็นข้อจำกัดของคอลัมน์อาจมีประสิทธิภาพมากกว่า

ในตัวอย่างต่อไปนี้ ระบบจะเรียกใช้การค้นหาหนึ่งรายการเพื่อตรวจสอบแถวที่จะแทรก และอีกรายการหนึ่งเพื่อแทรกจริง

Kotlin

// This is not the most efficient way of doing this.
// See the following example for a better approach.

db.rawQuery(
    """
    SELECT EXISTS (
        SELECT null
        FROM customers
        WHERE username = ?
    );
    """.trimIndent(),
    arrayOf(customer.username)
).use { cursor ->
    if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
        throw AddCustomerException(customer)
    }
}
db.execSQL(
    "INSERT INTO customers VALUES (?, ?, ?)",
    arrayOf(
        customer.id.toString(),
        customer.name,
        customer.username
    )
)

Java

// This is not the most efficient way of doing this.
// See the following example for a better approach.

try (Cursor cursor = db.rawQuery("""
    SELECT EXISTS (
      SELECT null
      FROM customers
      WHERE username = ?
    );
    """, new String[] { customer.username })) {
  if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
    throw new AddCustomerException(customer);
  }
}
db.execSQL(
    "INSERT INTO customers VALUES (?, ?, ?)",
    new String[] {
      String.valueOf(customer.id),
      customer.name,
      customer.username,
    });

แทนที่จะตรวจสอบข้อจำกัดที่ไม่ซ้ำกันใน Kotlin หรือ Java คุณสามารถตรวจสอบใน SQL เมื่อกำหนดตารางได้ ดังนี้

CREATE TABLE Customers(
  id INTEGER PRIMARY KEY,
  name TEXT,
  username TEXT UNIQUE
);

SQLite จะทำสิ่งเดียวกันดังนี้

CREATE TABLE Customers(...);
CREATE UNIQUE INDEX CustomersUsername ON Customers(username);

ตอนนี้คุณสามารถแทรกแถวและให้ SQLite ตรวจสอบข้อจำกัดได้แล้ว

Kotlin

try {
    db.execSQL(
        "INSERT INTO Customers VALUES (?, ?, ?)",
        arrayOf(customer.id.toString(), customer.name, customer.username)
    )
} catch(e: SQLiteConstraintException) {
    throw AddCustomerException(customer, e)
}

Java

try {
  db.execSQL(
      "INSERT INTO Customers VALUES (?, ?, ?)",
      new String[] {
        String.valueOf(customer.id),
        customer.name,
        customer.username,
      });
} catch (SQLiteConstraintException e) {
  throw new AddCustomerException(customer, e);
}

SQLite รองรับดัชนีที่ไม่ซ้ำกันซึ่งมีหลายคอลัมน์ ดังนี้

CREATE TABLE table(...);
CREATE UNIQUE INDEX unique_table ON table(column1, column2, ...);

SQLite ตรวจสอบข้อจำกัดได้เร็วกว่าและมีค่าใช้จ่ายในการดำเนินการน้อยกว่าโค้ด Kotlin หรือ Java แนวทางปฏิบัติแนะนำคือใช้ SQLite แทนโค้ดแอป

รวมการแทรกหลายรายการไว้ในธุรกรรมเดียว

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

Kotlin

db.beginTransaction()
try {
    customers.forEach { customer ->
        db.execSQL(
            "INSERT INTO Customers VALUES (?, ?, ?)",
            arrayOf(customer.id.toString(), customer.name, "customerValue")
        )
    }
    db.setTransactionSuccessful()
} finally {
    db.endTransaction()
}

Java

db.beginTransaction();
try {
  for (Customer customer : customers) {
    db.execSQL(
        "INSERT INTO Customers VALUES (?, ?, ?)",
        new String[] {
          String.valueOf(customer.id),
          customer.name,
          "customerValue"
        });
  }
  db.setTransactionSuccessful();
} finally {
  db.endTransaction();
}

เก็บงานที่ไม่ใช่ฐานข้อมูลไว้นอกธุรกรรม อย่าเก็บธุรกรรมการเขียนแบบเปิดไว้ใน I/O ของไฟล์ที่บล็อก เช่น File.delete, คำขอเครือข่าย, การสื่อสารระหว่างโปรเซส เช่น การเรียกหรือการออกอากาศ ContentResolver หรือการรับล็อก ดังนี้

  • การเขียนฐานข้อมูลพร้อมกันจะบล็อกจนกว่าธุรกรรมจะสิ้นสุด และหากไม่มี WAL การอ่านก็จะบล็อกด้วย
  • การรับการล็อกแอปในระหว่าง beginTransaction และ endTransaction มีความเสี่ยงที่จะเกิดการหยุดชะงักหากเทรดอื่นมีการล็อกนั้นขณะรอการเชื่อมต่อฐานข้อมูล
  • การย้อนกลับธุรกรรมที่ล้มเหลวจะไม่ยกเลิกผลข้างเคียงภายนอก เช่น ไฟล์ที่ถูกลบ และการออกอากาศที่ส่งก่อนที่ endTransaction จะคอมมิตจะปลุกตัวรับสัญญาณก่อนที่การเปลี่ยนแปลงของคุณจะปรากฏ

เตรียมอินพุตภายนอกก่อนเรียกใช้ beginTransaction, เรียกใช้เฉพาะการดำเนินการ SQLite ระหว่าง beginTransaction และ endTransaction และบันทึกเส้นทางไฟล์หรือเพย์โหลดในหน่วยความจำเพื่อเรียกใช้การล้างข้อมูลหรือส่งการออกอากาศหลังจากคอมมิต endTransaction

หากฐานข้อมูลอ้างอิงไฟล์ที่เปลี่ยนแปลงไม่ได้ ให้จัดเก็บไฟล์เหล่านั้นไว้ในไดเรกทอรีระดับบนเดียว และสร้าง เขียน และซิงค์ไฟล์แต่ละไฟล์ภายใต้ชื่อที่ไม่ซ้ำกันก่อนเริ่มธุรกรรม เนื่องจากชื่อไฟล์ไม่ซ้ำกันและฐานข้อมูลเป็นแหล่งข้อมูลที่ถูกต้องสำหรับไฟล์ที่ใช้งานอยู่ ให้ข้ามขั้นตอนการเปลี่ยนชื่อแบบอะตอมมิก หากต้องการล้างไฟล์ที่เหลืออยู่จากธุรกรรมที่ย้อนกลับหรือแถวที่ถูกแทนที่ ให้กำหนดเวลางาน WorkManager เป็นระยะๆ ในตัวดำเนินการเขียนตามลำดับเดียวกัน (หรือภายใต้การล็อกที่ชัดเจนเดียวกัน) ซึ่งจะจัดลำดับการเขียนฐานข้อมูลและการสร้างไฟล์ เพื่อให้การล้างข้อมูลค้นหาแถวที่ใช้งานอยู่และลบไฟล์ที่ไม่ได้อ้างอิงโดยไม่แย่งกับตัวเขียนที่กำลังทำงานอยู่