审查安卓本地数据持久化实现
检查 Android 应用的 Room、数据库迁移及本地存储流程,识别数据丢失、迁移错误和账户隔离问题,并整理审计发现。
完整提示词
# ANDROID PERSISTENCE AND ROOM AUDIT
I want you to perform a maximally deep, systematic, evidence-first, and production-oriented analysis of the entire persistence layer of the Android application, with a dedicated focus on Room, SQLite, DataStore, SharedPreferences, file storage, caches, and local sources of truth.
Primary objective:
> Determine whether the application reliably stores, migrates, reads, updates, and deletes local data without data loss, corruption, race conditions, cross-user leakage, inconsistent entity relations, or defects that only surface after multiple sequential app version upgrades.
This is not:
- a generic Room checklist
- advice to simply "use the Repository pattern"
- automated addition of indexes
- blindly migrating SharedPreferences to DataStore
- recommending wrapping everything in transactions
- a superficial scan of DAO interfaces
- analyzing only the current schema version
- assuming that a passing migration test proves semantic data integrity
The focus is on the real data lifecycle:
```text
create
↓
read
↓
update
↓
delete
↓
migration
↓
backup / restore
↓
logout / account switch
↓
app update
↓
process death
↓
recovery
```
Priority:
**data integrity > migration safety > transaction correctness > account isolation > recoverability > query correctness > performance > architecture elegance**
It is far better to find 6 genuine persistence defects that can lose or misrepresent user data than to write 100 generic Room recommendations.
---
# 1. DETERMINE PERSISTENCE STACK
Prior to analysis, identify:
- Room version
- SQLite layer
- Current database version
- `exportSchema` configuration
- Migration strategy
- DAO structure
- Entity models
- Relations (`@Relation`, `@Embedded`)
- Indexes
- Foreign keys and cascade policies
- TypeConverters
- Jetpack DataStore (Preferences / Proto)
- SharedPreferences
- File persistence
- Cache directories
- Encrypted storage (e.g. EncryptedSharedPreferences, SQLCipher) if present
- Backup, import, and export mechanisms
- Sync and offline-first data models
- Multi-account / multi-tenant data architecture
- WorkManager persistence interactions
Inspect at minimum:
- `@Database` definitions
- `@Entity` classes
- `@Dao` interfaces
- Migration implementations
- Database callbacks (`RoomDatabase.Callback`)
- Repository implementations
- DataStore instances
- SharedPreferences accessors
- File I/O utilities
- Backup / restore routines
- Automated persistence tests
- Versioned schema JSON files
---
# 2. MAP DATA OWNERSHIP ARCHITECTURE
For each critical data domain, specify:
```text
Data:
Owner:
Source of truth:
Local storage:
Remote storage:
User-scoped:
Durable:
Cache-only:
Retention:
```
Example:
```text
User Profile
↓
Server authority
↓
Room cache
↓
User-scoped
```
or:
```text
Form Draft
↓
Local authority
↓
Room table
↓
Must survive process death
```
You cannot accurately evaluate persistence correctness without establishing data ownership.
---
# 3. SINGLE SOURCE OF TRUTH
For each feature, answer:
> Which copy of the data is authoritative?
Possible authorities:
- Remote server
- Room database
- DataStore
- Local file
- In-memory state
- Hybrid offline-first model
Identify scenarios where the UI can observe conflicting data from multiple local or remote sources without a deterministic reconciliation hierarchy.
---
# 4. DATABASE ARCHITECTURE
Map the execution path:
```text
UI
↓
ViewModel
↓
Repository
↓
DAO
↓
Room
↓
SQLite
```
If the repository merges remote and local sources:
```text
API response
↓
Repository
↓
Transaction
↓
Room database
↓
Flow emission
↓
UI state
```
Trace the actual runtime execution pipeline.
---
# 5. DATABASE VERSION HISTORY
Determine the current Room database version.
Identify all historically supported versions still active in production.
Construct a version ledger:
| Version | Schema change | Migration | Tested |
|---|---|---|---|
If version history is unavailable:
**HISTORICAL SCHEMA COVERAGE: NOT VERIFIED**
---
# 6. MIGRATION GRAPH
Do not inspect only the latest migration step:
```text
v6 -> v7
```
Evaluate the entire multi-version upgrade graph:
```text
v1
↓
v2
↓
v3
↓
v4
↓
v5
↓
v6
↓
v7
```
Users frequently skip intermediate application releases.
---
# 7. SKIPPED VERSION UPGRADES
Scenario:
```text
User is on app DB v2
↓
Does not update for 2 years
↓
Installs latest app release requiring DB v9
```
Ask:
> Does a valid, unbroken migration path exist from v2 to v9?
Never assume Play Store users install every sequential app release.
---
# 8. DIRECT MIGRATIONS
If direct multi-version migrations exist:
```text
2 -> 5
```
verify that they do not conflict or desynchronize with step-by-step chain migrations (`2 -> 3 -> 4 -> 5`).
---
# 9. DESTRUCTIVE MIGRATIONS
Search for:
- `fallbackToDestructiveMigration()`
- `fallbackToDestructiveMigrationOnDowngrade()`
- Custom file or table deletion routines
For each usage, determine:
> What user data is permanently destroyed when this triggers?
If the data is merely a rebuildable network cache, the severity is low.
If the data is user-generated and the sole durable copy:
The severity is critical (P0 / P1).
---
# 10. MIGRATION CONTENT CORRECTNESS
A migration that executes valid SQL syntax can still corrupt data semantics.
Example:
```text
Old column status INTEGER (0 = DRAFT, 1 = SENT)
↓
New column status TEXT
```
Verify that all existing integer values are transformed into their exact semantic string equivalents.
---
# 11. DEFAULT VALUES IN MIGRATIONS
When adding a `NOT NULL` column during migration, check:
- Defined default value
- Semantic validity of the default for historical records
- Consistency across existing rows
Do not accept an arbitrary fallback value simply because the migration succeeds syntactically.
---
# 12. COLUMN RENAMES
Verify that a column rename does not inadvertently execute as:
```text
Add new column
↓
Historical data never migrated from old column
```
resulting in silent data loss.
---
# 13. TABLE REBUILD PATTERN
When executing the standard SQLite table recreation pattern:
```text
CREATE TABLE new_table (...)
↓
INSERT INTO new_table SELECT ... FROM old_table
↓
DROP TABLE old_table
↓
ALTER TABLE new_table RENAME TO old_table
```
verify:
- Every column mapping
- Nullability constraints
- Default column values
- Secondary indexes
- Foreign key constraints
---
# 14. INDEX PRESERVATION AFTER MIGRATION
Table recreations frequently drop associated indexes.
Compare the final migrated schema against the official Room entity annotations.
---
# 15. FOREIGN KEY PRESERVATION AFTER MIGRATION
Apply the exact same verification to foreign key constraints following table rebuilds.
---
# 16. DATABASE TRIGGERS
If the database defines raw SQLite triggers, verify that migrations do not leave triggers detached or dropped.
---
# 17. DATABASE VIEWS
If database views (`@DatabaseView`) are used, verify schema compatibility across migrations.
---
# 18. FULL TEXT SEARCH (FTS)
If Full Text Search tables (`@Fts3`, `@Fts4`) are used:
- External content table synchronization
- Tokenizer configurations
- FTS index rebuild routines
- Migration compatibility
Analyze carefully.
---
# 19. TYPE CONVERTERS
Inspect every `@TypeConverter` method repository-wide.
Look for:
- Unstable or unversioned serialization formats
- Storing Enums by `name` or `ordinal`
- Locale-dependent date and number formatters
- Ambiguous timezone mappings
- Flawed null handling
---
# 20. ENUM PERSISTENCE HAZARDS
If an enum is persisted via:
```text
enum.name
```
renaming an enum constant renders all historical records unreadable.
If persisted via `enum.ordinal`:
inserting or reordering constants silently corrupts existing database records.
Verify the actual storage representation.
---
# 21. STABLE PERSISTED ENUM VALUES
If business data must survive across years of releases, persisted enum values must adhere to an immutable mapping contract.
Do not alter enum mappings without a comprehensive schema migration plan.
---
# 22. DATE AND TIME STORAGE
Determine how timestamps are stored:
- Epoch milliseconds (Long)
- Epoch seconds (Long)
- ISO-8601 strings (Text)
- Local date strings (Text)
- Timezone-aware composite fields
Identify implicit assumptions regarding device local timezone vs UTC.
---
# 23. EPOCH UNIT DISCREPANCIES
Verify that seconds and milliseconds are not conflated between network API models, Room storage, and UI presentation.
---
# 24. LOCAL DATE VS INSTANT
A date of birth (`LocalDate`) and a server audit timestamp (`Instant`) represent fundamentally different temporal concepts.
Verify that the persistence model matches the business domain.
---
# 25. FINANCIAL VALUES AND MONEY
If monetary values or balances are stored as floating-point numbers (`Float` / `Double`):
Flag the precision and rounding hazard.
Financial values must use integer cents (`Long`) or fixed-precision string representations (`BigDecimal`).
---
# 26. DECIMAL SERIALIZATION
When serializing decimals to strings, never use locale-aware formatters that output comma separators instead of decimal dots.
---
# 27. LEGACY BOOLEAN MAPPINGS
If legacy schemas store booleans as integers (`0` / `1`) or strings (`"true"` / `"false"`), verify exhaustive mapping across all queries and converters.
---
# 28. JSON IN DATABASE COLUMNS
If complex objects are stored as JSON blobs in text columns:
Examine:
- Schema evolution handling
- Deserialization of unknown or newly added fields
- Missing field fallback defaults
- Inability to query internal properties
- Partial document corruption risks
---
# 29. VERSIONED JSON DOCUMENTS
If JSON columns store durable user-generated content, include an internal version tag to support forward and backward compatibility.
Do not mandate versioning for transient cache blobs.
---
# 30. ENTITY DEFINITION AUDIT
For each critical `@Entity`, examine:
- Primary key stability
- Nullability constraints
- Column default values
- Indexes
- Foreign key constraints
- Unique constraints
- User / tenant scoping
---
# 31. PRIMARY KEY STABILITY
Ask:
> Does this ID represent an immutable identity for this entity?
Look for:
- Mutable business fields used as primary keys
- Locally generated auto-increment IDs with no server ID mapping
- ID collision risks across devices
---
# 32. AUTO-GENERATED IDS IN SYNC SYSTEMS
In offline-first systems, verify how locally generated auto-increment IDs reconcile with server-assigned UUIDs upon synchronization.
---
# 33. COMPOSITE KEYS
If entity identity spans multiple attributes, ensure composite keys prevent duplicate logical records.
---
# 34. UNIQUE CONSTRAINTS
Core business invariants must be protected by database-level unique constraints rather than application-level checks.
Example:
```text
UNIQUE(user_id, provider_account_id)
```
Never rely solely on:
```text
if (!dao.exists(id)) dao.insert(entity)
```
under concurrent workloads.
---
# 35. NULLABILITY MISMATCHES
Compare:
- Kotlin property nullability (`T` vs `T?`)
- SQLite column nullability (`NOT NULL`)
- Remote API response nullability
- Schema migration scripts
Identify discrepancies that trigger runtime deserialization crashes.
---
# 36. DEFAULT VALUE MISMATCHES
A default value defined on a Kotlin data class property does NOT automatically translate into an SQLite column default.
Verify the generated SQLite schema output.
---
# 37. FOREIGN KEY POLICIES
For every relational entity, inspect:
- Parent table
- Child table
- `onDelete` action
- `onUpdate` action
---
# 38. CASCADE DELETE HAZARDS
`ForeignKey.CASCADE` can be intentional or disastrous.
Trace:
```text
DELETE FROM parent
↓
Which child rows are silently deleted?
```
---
# 39. RESTRICT AND NO ACTION POLICIES
If parent deletion fails due to active child constraints, verify how the application catches and displays the error to the user.
---
# 40. ORPHAN RECORD ACCUMULATION
If foreign keys are omitted, verify that deletion routines explicitly delete dependent child records to prevent database bloat.
---
# 41. SOFT DELETE SEMANTICS
If soft delete patterns are used:
- `is_deleted` flag
- `archived` boolean
- `deleted_at` timestamp
verify that ALL queries consistently filter out soft-deleted records where appropriate.
---
# 42. SOFT DELETE VS UNIQUE CONSTRAINTS
A soft-deleted row can still violate a table unique constraint if the user creates a replacement record with the same unique identifier.
Verify business expectations.
---
# 43. ROOM RELATIONS AUDIT
Review `@Relation` and `@Embedded` usage.
Check for:
- N+1 sub-queries
- Unbounded result sets
- Transactional consistency during relation loading
---
# 44. `@Transaction` ON RELATION METHODS
Because Room loads `@Relation` properties via separate queries, the parent query method MUST be annotated with `@Transaction` to guarantee a consistent snapshot.
---
# 45. DAO METHOD INVENTORY
Classify all DAO operations:
```text
READ
CREATE
UPDATE
DELETE
UPSERT
TRANSACTION
MAINTENANCE
```
---
# 46. RAW QUERY AUDIT
Scrutinize every `@RawQuery` method.
Check for:
- Dynamic SQL string concatenation vulnerabilities
- Incomplete table invalidation tracking
- Projection mismatches
- Maintainability risks
---
# 47. STRING-CONCATENATED SQL
Look for user-supplied strings directly interpolated into raw SQL queries instead of parameterized query bindings.
Flag as critical correctness and security hazards.
---
# 48. QUERY CORRECTNESS
For critical SQL queries, evaluate:
- `WHERE` clause logic
- `JOIN` semantics (INNER vs LEFT)
- Aggregation and grouping
- Ordering determinism
- Paging limits
- SQL `NULL` handling
Do not focus solely on performance; correctness takes priority.
---
# 49. SQL NULL SEMANTICS
In SQL:
```sql
WHERE column = NULL
```
never evaluates to true; it must be written as:
```sql
WHERE column IS NULL
```
Check dynamically generated query filters.
---
# 50. `NOT IN` WITH NULLS
If a sub-query or list passed to `NOT IN` contains a `NULL` value, SQLite evaluates the entire expression to `NULL`, returning zero records.
Verify concrete usages.
---
# 51. JOIN RESULT DUPLICATION
An `INNER JOIN` or `LEFT JOIN` across a one-to-many relationship duplicates parent rows for each matching child.
Verify mapping logic into UI or domain models.
---
# 52. MISUSE OF DISTINCT
Do not insert `DISTINCT` merely to patch a flawed join query.
Identify and resolve the root cause of the row duplication.
---
# 53. GROUP BY ARTIFACTS
SQLite allows selecting non-aggregated columns in a `GROUP BY` query, which returns arbitrary row values.
Verify query determinism.
---
# 54. DETERMINISTIC ORDERING
Without an explicit `ORDER BY` clause, SQLite row retrieval order is non-deterministic.
If business logic assumes stable ordering, an explicit sort clause is mandatory.
---
# 55. TIEBREAKER SORTING
If multiple records share identical primary sort values, append a secondary stable tiebreaker (e.g. `id ASC`) to ensure consistent pagination.
---
# 56. PAGINATION STABILITY
If using `LIMIT / OFFSET`, ordering must be strictly deterministic.
Otherwise, items will appear duplicated or be skipped entirely as the user scrolls.
---
# 57. OFFSET PAGINATION SCALING
High offset queries (`OFFSET 10000`) force SQLite to scan and discard thousands of rows.
Assess based on realistic dataset expectations.
---
# 58. KEYSET PAGINATION
Keyset pagination (`WHERE id > :lastId ORDER BY id LIMIT :size`) provides O(1) page access for massive datasets.
Recommend only when dataset volume warrants the added query complexity.
---
# 59. SINGLE-ROW QUERIES
Queries expected to return a single entity must define behavior when duplicates exist (`LIMIT 1`).
---
# 60. `SELECT *` EVALUATION
Do not report `SELECT *` as an automatic defect.
It is problematic only when the entity contains massive BLOB or text columns and the UI consumes a small fraction of the attributes.
---
# 61. LARGE BLOB STORAGE
Storing large binary blobs (photos, audio recordings, PDFs) inside SQLite rows degrades query performance and increases memory churn.
Evaluate offloading to local file storage while retaining relative file paths in the database.
---
# 62. CURSOR WINDOW OVERFLOW
A single row exceeding the Android CursorWindow limit (typically 2MB) triggers a `RowTooBigException` crash.
Verify payload dimensions.
---
# 63. INDEX AUDIT
For each critical query, inspect:
- Filter equality predicates
- Range operators (`<`, `>`, `BETWEEN`)
- `JOIN` condition columns
- `ORDER BY` sort columns
Do not blindly add single-column indexes on every table column.
---
# 64. INDEX WRITE OVERHEAD
Every additional index increases disk storage and slows down `INSERT`, `UPDATE`, and `DELETE` operations.
Recommend indexes only with demonstrable query advantages.
---
# 65. COMPOSITE INDEX COLUMN ORDERING
Column order in composite indexes matters significantly.
The leftmost columns must match the equality filters of the query.
---
# 66. REDUNDANT INDEXES
A composite index on `(A, B)` automatically covers single-column queries on `A`.
An isolated index on `A` is redundant.
---
# 67. QUERY PLAN VERIFICATION
Where tooling permits, inspect:
```sql
EXPLAIN QUERY PLAN
```
for critical queries.
Do not fabricate query plan metrics.
---
# 68. FULL TABLE SCANS
A full table scan on a table with 20 rows is completely benign.
Severity depends on query frequency and data growth projections.
---
# 69. N+1 QUERY DEFECTS
Trace:
```text
Load list of 500 items
↓
Loop through each item in Kotlin
↓
Execute individual DAO query per item
```
This degrades I/O performance significantly.
---
# 70. ROOM FLOW RE-EMISSION CHURN
Room invalidation operates at the table level.
Any write to a table triggers re-emission for ALL active Flow queries observing that table, even if the modified row is irrelevant to the query.
---
# 71. DUPLICATE FLOW COLLECTORS
Multiple collectors subscribing to an unshared cold Room Flow execute independent underlying database queries.
Verify repository sharing (`shareIn` / `stateIn`).
---
# 72. TRANSACTION BOUNDARIES
Map all business workflows that mutate multiple rows or tables.
Ask:
> Is it acceptable for another reader to observe a half-executed state?
If not, a strict atomic transaction boundary is mandatory.
---
# 73. `@Transaction` SCOPING
Do not add `@Transaction` indiscriminately.
Reserve it for multi-step mutations and relation queries requiring atomic consistency.
---
# 74. TRANSACTIONS ACROSS NETWORK CALLS
Never hold an open SQLite transaction while waiting for a remote network response.
This locks the database file and stalls all concurrent readers and writers.
---
# 75. PARTIAL WRITE HANDLING
Scenario:
```text
Insert parent order
↓
Insert 10 line items
↓
Failure occurs on item 5
```
Without an enclosing transaction, partial orphaned records persist in the database.
---
# 76. ATOMIC IMPORT TRANSACTIONS
File imports or backup restorations that replace table data must execute inside a single transaction to allow complete rollback on failure.
---
# 77. RESTORATION FAILURES
If database restoration fails halfway:
> Does the previous database remain intact, or is the user left with a corrupted, half-restored dataset?
---
# 78. STAGING DATABASE RESTORATION PATTERN
For mission-critical restore flows, restore into a temporary database file first, validate integrity, and atomically swap files.
---
# 79. CONCURRENCY AND RACE CONDITIONS
Room handles thread dispatching, but high-level application logic can still introduce concurrency race conditions.
---
# 80. READ-MODIFY-WRITE HAZARDS
Scenario:
```text
Read balance from DB
↓
Compute new balance in Kotlin
↓
Update balance in DB
```
Two concurrent coroutines will cause a lost update.
---
# 81. SQL-LEVEL ATOMIC UPDATES
Where appropriate, execute atomic arithmetic directly in SQLite:
```sql
UPDATE accounts SET balance = balance + :amount WHERE id = :id
```
rather than reading and writing back modified state.
---
# 82. `@Upsert` SEMANTICS
Understand Room `@Upsert` behavior:
Verify whether a conflict is truly intended to overwrite existing data, or if conflict indicates an unexpected error condition.
---
# 83. SQLITE REPLACE SIDE EFFECTS
SQLite `OnConflictStrategy.REPLACE` executes as a `DELETE` followed by an `INSERT`.
This resets auto-increment IDs and triggers `CASCADE` deletions on related foreign key tables.
---
# 84. CONFLICT STRATEGIES
Analyze:
- `OnConflictStrategy.ABORT`
- `OnConflictStrategy.IGNORE`
- `OnConflictStrategy.REPLACE`
against core domain invariants.
---
# 85. `OnConflictStrategy.IGNORE` HAZARDS
Using `IGNORE` silently swallows insert failures.
Ensure the caller verifies row insertion status when success is mandatory.
---
# 86. UPDATE AFFECTED ROW COUNTS
When updating an entity, verify the return count:
```kotlin
@Update
suspend fun update(item: Item): Int
```
If the count is 0, the record was already deleted or modified by another worker.
---
# 87. DELETE AFFECTED ROW COUNTS
Apply the same verification to delete operations.
---
# 88. OPTIMISTIC CONCURRENCY CONTROL
If multi-client or multi-worker updates occur, verify versioning tokens (`version` or `updated_at`) to reject stale writes.
---
# 89. DATABASE AS A CACHE
When Room acts strictly as an offline mirror of remote data, verify clear cache invalidation and eviction policies.
---
# 90. DATABASE AS SOURCE OF TRUTH
When the UI observes Room as the single source of truth, ensure all network updates write to Room before the UI expects state updates.
---
# 91. DUAL-SOURCE DISAGREEMENT
If the UI consumes network responses directly in some places while observing Room Flows in others, brief state desynchronization occurs.
---
# 92. OFFLINE MUTATION DURABILITY
When user edits are written locally while offline:
```text
Local write
↓
Marked as pending sync
↓
Background sync worker dispatches to server
```
verify durability of the pending mutation metadata.
---
# 93. PENDING MUTATION PERSISTENCE
Pending sync tasks must survive:
- OS process death
- Application restarts
- Device reboots
if the app promises guaranteed eventual synchronization.
---
# 94. TOMBSTONE RECORDS
If deletions must be synchronized with the remote backend, deleting the local row immediately loses tracking metadata.
Use tombstone records (`is_deleted = 1`) to preserve deletion markers until synced.
---
# 95. SYNC METADATA ATTRIBUTES
Verify standard synchronization columns:
- `is_dirty`
- `is_synced`
- `sync_pending`
- `version`
- `server_id`
- `deleted_at`
---
# 96. SYNC METADATA ACROSS MIGRATIONS
Pending unsynced mutations can reside in local tables during an application upgrade.
Verify that new migrations preserve pending synchronization states.
---
# 97. DATASTORE INVENTORY
Map all DataStore keys and Proto definitions.
Classify:
```text
USER-SCOPED
DEVICE-SCOPED
APP-SCOPED
CACHE
CONFIG
```
---
# 98. PREFERENCES DATASTORE AUDIT
Look for:
- Key string typos
- Duplicate key declarations
- Renamed keys without migrations
- Semantic changes to default fallback values
---
# 99. PROTO DATASTORE SCHEMA EVOLUTION
Verify Protocol Buffer backward and forward compatibility rules.
Never reuse deleted field numbers.
---
# 100. DATASTORE MIGRATIONS
When migrating from legacy SharedPreferences to DataStore, check:
- Target key sets
- Migration triggers
- Handling of partial migrations
- Legacy file cleanup
---
# 101. SHAREDPREFERENCES AUDIT
Do not label SharedPreferences as an acute bug simply because modern DataStore exists.
Report genuine defects such as:
- Synchronous `.commit()` blocking the UI thread
- Multi-process write race conditions
- Lack of corruption recovery
- Context leaks
---
# 102. `commit()` VS `apply()`
Synchronous `.commit()` on the Main thread introduces ANR risks.
However, background tasks requiring confirmation of disk write before proceeding may require `.commit()`.
Analyze context.
---
# 103. FILE PERSISTENCE AUDIT
Map file storage locations:
- Internal files directory (`context.filesDir`)
- Cache directory (`context.cacheDir`)
- External storage (`context.getExternalFilesDir()`)
- Temporary storage
Ask:
> Does the storage location guarantee the retention lifecycle expected by the feature?
---
# 104. CACHE DIRECTORY PURGING
The Android OS automatically purges files in `cacheDir` when the device experiences storage pressure.
Never store the sole durable copy of user-generated data in cache directories.
---
# 105. TEMPORARY FILES
Verify prompt deletion of temporary files in both success and crash scenarios.
---
# 106. ATOMIC FILE WRITES
Scenario:
```text
Open target file
↓
Truncate content
↓
Write bytes
↓
Process terminates halfway
```
The resulting file is corrupted.
Use atomic file writes (e.g. `AtomicFile` write-to-temp-then-rename) for critical configuration and document saves.
---
# 107. FILE FORMAT VERSIONING
If the app persists custom file formats, verify version headers for schema evolution.
---
# 108. EXPORT FILE INTEGRITY
Backup export files must specify:
- Format version
- Character encoding (UTF-8)
- Data boundary scope
- Checksum / integrity hashes
where appropriate.
---
# 109. IMPORT DATA VALIDATION
Treat imported files as untrusted external inputs.
Validate:
- Structural schema integrity
- Mandatory attributes
- Primary key collision handling
- Valid enum values
- File size boundaries
- Duplicate records
---
# 110. IMPORT MEMORY CONSUMPTION
Avoid reading multi-megabyte import files entirely into memory as strings.
Use streaming parsers (e.g. Jackson / Moshi / Kotlinx Serialization streaming) to prevent OutOfMemory crashes.
---
# 111. BACKUP COMPLETENESS
Inventory all durable application storage.
Ask:
> Does the backup routine truly capture all persistent state?
State may be fragmented across:
- Room databases
- DataStore files
- Dedicated internal files
---
# 112. BACKUP CONSISTENCY
If Room databases and local media files are backed up separately while writes remain active, the resulting backup snapshot will be mutually inconsistent.
---
# 113. RESTORATION DEPENDENCY ORDER
If the database references local media files, ensure restoration restores files before inserting database records to prevent broken references.
---
# 114. INTEGRITY CHECKSUMS
For mission-critical backups, calculate checksums (e.g. SHA-256) to detect corrupted or truncated backups prior to restoring.
---
# 115. ACCOUNT DATA SCOPING
A primary security and privacy audit checkpoint.
For every user-specific table, ask:
> How is each row partitioned by user identity?
---
# 116. USER ID PARTITIONING
If the app supports multiple user accounts without wiping the database, verify that all entity tables include a `user_id` partition column.
---
# 117. LOGOUT STORAGE CLEANUP
Trace logout execution across:
```text
Logout initiated
↓
Room tables
↓
DataStore preferences
↓
SharedPreferences
↓
Internal files
↓
Cache directories
```
What private data remains on disk?
---
# 118. CROSS-USER DATA LEAKAGE
Scenario:
```text
User A logs in and syncs private records
↓
User A logs out
↓
User B logs in
↓
Active Room Flow emits User A records to User B
```
This represents an acute P0 / P1 privacy finding.
---
# 119. DATABASE PER ACCOUNT
If the app isolates users via separate database files:
- File naming conventions
- Safe connection closure and reopening
- Deletion on account removal
- Account-switching race conditions
Verify thoroughly.
---
# 120. SHARED DATABASE WITH ACCOUNT FILTERING
If a single database file is shared across accounts, verify that every DAO query explicitly filters by `user_id`.
---
# 121. MISSING USER_ID PREDICATES
A DAO query such as:
```sql
SELECT * FROM messages
```
in a shared database leaks all historical users' private messages to the active user.
---
# 122. TENANT ISOLATION
Apply the exact same rigor to multi-tenant B2B enterprise applications.
---
# 123. LOGOUT DURING IN-FLIGHT WRITES
Scenario:
```text
User A initiates a save mutation
↓
User A logs out immediately
↓
User B logs in
↓
User A's pending write completes and commits
```
Verify that User A's data does not commit into User B's account scope.
---
# 124. DATABASE INSTANCE LIFECYCLE
If database instances are closed and reopened upon account switching, verify active Flow collectors and coroutine scopes.
---
# 125. CLOSED DATABASE ACCESS
A lingering repository from a previous session querying a closed database instance crashes the application.
---
# 126. ANDROID AUTO BACKUP RULES
Inspect `dataExtractionRules.xml` and `backup_rules.xml`.
Ensure sensitive tokens, account sessions, and device-bound keys are excluded from cloud backups (`android:fullBackupContent`).
---
# 127. DEVICE-TO-DEVICE RESTORATION RISKS
Data restored onto a brand-new device may be invalid or dangerous:
- Push notification device tokens
- Hardware-bound encryption keys
- Device-specific configuration flags
- Cached server session tokens
---
# 128. KEYSTORE RESTORATION HAZARDS
Data encrypted via Android Keystore keys becomes permanently unreadable if restored onto a different device, because Keystore keys do not migrate.
---
# 129. DOWNGRADE BEHAVIOR
If a user or QA engineer installs an older app version over a newer database schema:
Determine whether downgrades are explicitly supported or intentionally fail fast.
If not supported:
**DOWNGRADE SUPPORT: NOT REQUIRED / NOT VERIFIED**
---
# 130. DATABASE CORRUPTION HANDLING
Examine handling for:
- SQLite disk corruption (`DatabaseErrorHandler`)
- Malformed DataStore files
- Corrupted internal storage files
---
# 131. DESTRUCTIVE RECOVERY POLICIES
If the corruption handler deletes the database file:
Determine whether the database contains disposable cache or irreplaceable local user data.
Severity corresponds directly to data recoverability.
---
# 132. DATASTORE CORRUPTION HANDLER
If configured, verify what fallback state is returned and whether user settings are wiped.
---
# 133. DISK FULL SCENARIOS
Storage exhaustion during a write operation triggers an `IOException` or SQLite disk full error.
Ensure the UI does not report success before the write has successfully committed.
---
# 134. FALSE SUCCESS NOTIFICATIONS
Scenario:
```text
User taps Save
↓
UI immediately shows "Saved Successfully"
↓
Database write fails in background
```
This represents an acute reliability and data loss defect.
---
# 135. DURABILITY BOUNDARIES
For each critical mutation, determine:
> At what exact point does the application signal to the user that their data is safely persisted?
The confirmation must correspond to actual physical disk durability.
---
# 136. ROOM DATABASE CALLBACKS
Review:
- `onCreate`
- `onOpen`
- `onDestructiveMigration`
Check for heavy blocking operations, redundant initializations, or non-idempotent seed scripts.
---
# 137. PRE-POPULATED DATABASES
If the app ships a pre-populated database asset (`createFromAsset`):
- Schema version alignment
- Subsequent migration compatibility
- Initial copy execution
- First-open latency
Must be validated.
---
# 138. SEED DATA IDEMPOTENCY
Database seeding scripts must be idempotent (`INSERT OR IGNORE`) to handle repeated execution safely.
---
# 139. DEMO AND TEST DATA LEAKS
Ensure mock seed data or debug testing records do not leak into production release builds.
---
# 140. DATABASE ENCRYPTION
If using SQLCipher or similar database encryption:
- Key derivation and lifecycle
- Migration compatibility
- Backup exclusions
- Query performance overhead
Do not mandate database encryption without an explicit threat model.
---
# 141. SENSITIVE CREDENTIAL STORAGE
Evaluate whether sensitive credentials (passwords, private cryptographic keys, auth tokens) belong in SQLite at all.
---
# 142. AUTH TOKEN STORAGE
Room is not automatically the wrong place for tokens, but Keystore encryption, memory scrubbing, and logout cleanup must be verified.
---
# 143. SEARCH QUERY HISTORY
Local search history constitutes private user data; ensure proper account scoping and logout clearing.
---
# 144. IN-DATABASE LOGGING
If the application writes diagnostic logs into local database tables, verify growth bounds and PII scrubbing.
---
# 145. DATA RETENTION POLICIES
For tables that accumulate rows over time, ask:
> What mechanism purges obsolete records?
---
# 146. UNBOUNDED TABLE GROWTH
Watch for:
- Historical event logs
- Diagnostic records
- Push notification logs
- Analytics queues
- Offline sync queues
growing indefinitely without automated pruning.
---
# 147. AUTOMATED CLEANUP TASKS
If automated pruning jobs exist, verify:
- Scheduling frequency
- Transaction batching (purging in chunks to avoid locking)
- Retention criteria
- Failure resilience
---
# 148. SQLITE VACUUM
Do not recommend executing `VACUUM` routinely without empirical need.
`VACUUM` locks the entire database and rewrites the database file, creating severe latency.
---
# 149. WRITE-AHEAD LOGGING (WAL)
Verify whether WAL mode is active.
WAL enables concurrent readers and writers, but do not alter journal modes without benchmarking.
---
# 150. WAL CHECKPOINTING
SQLite automatically manages checkpointing.
Flag issues only if custom configurations cause massive uncommitted `-wal` file growth.
---
# 151. DATABASE FILE SIZE
If not measured:
**DATABASE SIZE: NOT MEASURED**
Do not speculate.
---
# 152. STORAGE GROWTH ESTIMATES
Estimate growth strictly from verified record creation rates and schema sizes.
If real-world usage data is absent:
**GROWTH IMPACT: NOT VERIFIED**
---
# 153. QUERY PERFORMANCE CLASSIFICATION
For every performance finding, specify:
```text
MEASURED
CODE-LEVEL RISK
NOT MEASURED
```
---
# 154. QUERY EXECUTION FREQUENCY
A query taking 100ms executed once a day is negligible; a query taking 20ms executed 50 times per second during scrolling causes acute jank.
Always incorporate execution frequency.
---
# 155. DATABASE INITIALIZATION AT STARTUP
Opening or migrating a large database during application launch directly inflates cold start latency.
Cross-reference with performance audits.
---
# 156. MIGRATION EXECUTION TIME
Schema correctness takes priority, but massive migrations traversing millions of rows can block startup for seconds.
If unmeasured:
**MIGRATION DURATION: NOT MEASURED**
---
# 157. ASYNCHRONOUS MIGRATIONS
Room schema migrations must complete before the database connection is usable.
Do not suggest "running migrations in the background" without an architectural plan for blocking queries.
---
# 158. SCHEMA EXPORT DISCIPLINE
If the project sets:
```kotlin
exportSchema = true
```
verify that generated JSON schema files are committed to version control.
---
# 159. SCHEMA HISTORY UTILITY
Schema JSON files enable automated testing across historical versions.
Their absence is a testing and maintainability risk, not an immediate runtime bug.
---
# 160. ROOM AUTO MIGRATIONS
If using Room AutoMigrations (`@AutoMigration`):
Verify that the schema modification is truly supported automatically by Room.
---
# 161. AUTOMIGRATIONSPEC
When renaming or deleting columns and tables, verify that an explicit `@AutoMigrationSpec` provides disambiguation.
---
# 162. AUTOMIGRATION DATA SEMANTICS
An automated migration ensures structural schema correctness, but it does NOT perform semantic data transformations.
---
# 163. MIGRATION TEST SUITES
Look for `MigrationTestHelper` test suites.
Verify:
- Source schema instantiation
- Migration execution
- Final schema validation
- Concrete data assertions
---
# 164. VALIDATION VS DATA ASSERTIONS
`validateMigration()` verifies column definitions, but does not verify that row contents were preserved or transformed correctly.
---
# 165. DATA CONTENT ASSERTIONS
Example test assertion:
```kotlin
// Given historical record with status = 2
// When migrated to latest version
// Then new status column must equal "ARCHIVED"
```
Tests must assert data values, not merely database openability.
---
# 166. TESTING ALL HISTORICAL VERSIONS
For current database version v8, verify upgrade paths starting from all still-active supported versions, not merely v7 -> v8.
---
# 167. MIGRATION TEST MATRIX
Document:
| From | To | Schema tested | Data tested | Result |
|---|---|---|---|---|
---
# 168. DAO INTEGRATION TESTS
Test critical queries against real SQLite Room databases (e.g. in-memory database).
Mocking DAO interfaces does not validate SQL syntax or Room mapping logic.
---
# 169. QUERY EDGE CASES
Test against:
- Empty tables
- Single row
- Duplicate values
- Null attributes
- Soft-deleted parent records
- Identical timestamps
- Massive text payloads
---
# 170. TRANSACTION ROLLBACK TESTS
Deliberately trigger an exception midway through a multi-step write operation.
Verify that the entire transaction rolls back completely.
---
# 171. UNIQUE CONSTRAINT TESTS
Simulate concurrent or duplicate insertions to verify unique constraint enforcement.
---
# 172. ACCOUNT ISOLATION TESTS
In multi-user setups, test:
```text
Insert User A records
↓
Simulate logout and switch to User B
↓
Query User B data
↓
Assert zero records belonging to User A are returned
```
---
# 173. BACKUP RESTORATION TESTS
Do not test backups merely by verifying file creation.
Restore the backup file into a blank application state and assert complete data restoration.
---
# 174. END-TO-END ROUNDTRIP TESTS
The optimal verification:
```text
Seed complex state
↓
Export backup
↓
Clear application storage completely
↓
Import backup
↓
Assert semantic equivalence across all entities
```
---
# 175. ATTRIBUTE-LEVEL ROUNDTRIP VALIDATION
Verify that every critical entity attribute survives the backup and restore cycle unchanged.
---
# 176. MALFORMED IMPORT TESTING
Test imports against:
- Corrupted JSON / Protobuf
- Unsupported version numbers
- Duplicate entity IDs
- Missing mandatory fields
---
# 177. CRASHES DURING RESTORE
If the restore workflow is mission-critical, simulate process termination mid-restore.
Verify recoverability.
---
# 178. PROCESS DEATH DURING WRITES
SQLite transactions protect database file integrity, but high-level multi-step operations can remain partially complete.
Trace the entire business workflow.
---
# 179. UPGRADES WITH PENDING STATES
Before testing migrations, seed:
- Pending sync mutations
- Unsaved drafts
- Archived entities
- Relational joins
Ensure migrations preserve pending metadata.
---
# 180. LONG-TERM MULTI-VERSION HISTORIES
A mature production app must validate upgrades across realistic historical upgrade sequences, not just the latest diff.
---
# 181. FINDING FORMAT
Every serious finding must include:
```text
ID:
Severity:
Category:
Confidence:
Status:
Data type:
Table/File/Store:
Entity:
DAO:
Migration:
File:
Relevant code/schema:
Source of truth:
User-scoped:
Durability requirement:
Problem:
Evidence:
Data Lifecycle:
Reproduction:
Expected data state:
Actual/Possible data state:
Data loss impact:
Cross-user impact:
Migration impact:
Root cause:
Recommended remediation:
Regression test:
Verification:
Complexity:
XS / S / M / L / XL
```
If a field is not applicable:
**NOT APPLICABLE**
---
# 182. SEVERITY
Use:
## P0 - CRITICAL
- Cross-user private data exposure
- Irreversible catastrophic local data loss or corruption
- Critical backup or restore failure destroying the sole copy of user data
## P1 - HIGH
- User-generated data loss
- Broken migration path impacting existing production users
- Substantial cross-account data leakage
- Database file corruption during normal execution
- Multi-step write lacking transaction boundaries causing persistent partial state
## P2 - MEDIUM
- Noticeable data inconsistency
- Query returning incorrect data in realistic edge cases
- Migration defect with contained scope
- Stale local data with an available user workaround
## P3 - LOW
- Minor persistence edge case
- Non-critical cleanup or retention defect
## P4 - IMPROVEMENT
- Performance, testability, or schema architectural enhancement without an active correctness bug
---
# 183. CONFIDENCE
Use:
```text
HIGH
MEDIUM
LOW
```
HIGH:
SQL, schema definitions, or test execution directly prove the defect.
MEDIUM:
Code structure strongly indicates the defect, but production data is inaccessible.
LOW:
Hypothesis dependent on unknown dataset sizes, legacy states, or platform runtime quirks.
---
# 184. STATUS
Use:
```text
CONFIRMED
LIKELY
THEORETICAL
NOT VERIFIED
```
---
# 185. MIGRATION STATUS
For migration findings, append:
```text
SCHEMA FAILURE
DATA SEMANTICS FAILURE
UPGRADE PATH GAP
DESTRUCTIVE RISK
PERFORMANCE RISK
```
---
# 186. DATA CLASSIFICATION
For affected data, classify:
```text
CACHE
REBUILDABLE
USER-GENERATED
SERVER-RECOVERABLE
LOCAL-ONLY
SECURITY-SENSITIVE
NOT VERIFIED
```
Severity must reflect data recoverability.
---
# 187. FALSE POSITIVE PREVENTION
Before confirming a P0, P1, or P2 finding, review:
1. Entity definitions
2. DAO implementation
3. Repository layer
4. Transaction boundaries
5. Migration scripts
6. Schema JSON files
7. Database constraints
8. Synchronization logic
9. Logout and account reset flows
10. Automated tests
Never conclude an issue exists based on an isolated DAO method without tracing its call sites.
---
# 188. DO NOT ADD INDEXES BLINDLY
Before recommending an index, demonstrate:
```text
Critical query
↓
Filter / Join / Sort columns
↓
Missing supporting index
↓
Expected performance gain
```
If query plans are unmeasured:
**PERFORMANCE BENEFIT: NOT MEASURED**
---
# 189. DO NOT WRAP EVERYTHING IN TRANSACTIONS
Transactions are appropriate when multiple operations require atomicity or a consistent snapshot.
Do not mandate transactions for single-query DAO reads.
---
# 190. DO NOT WIPE DATABASES AS A FIX
Destructive fallback wipes user data to mask migration defects.
Never accept:
> If migration fails, wipe the database
as an acceptable production recovery strategy for unique, locally authored user data.
---
# 191. DO NOT MIGRATE SHAREDPREFERENCES MERELY FOR MODERNITY
If the existing SharedPreferences implementation functions correctly without thread-blocking or corruption risks, migration to DataStore is at most a P4 improvement.
---
# 192. DO NOT MODIFY CODE
During the audit:
- Do not alter entity classes
- Do not add indexes
- Do not increment database versions
- Do not draft migration scripts
- Do not delete database files
- Do not alter backup formats
Complete the audit first.
---
# 193. OUTPUT - ANDROID_PERSISTENCE_ROOM_AUDIT.md
Structure the final audit report:
## 1. Executive Summary
- Persistence architecture overview
- Room / database version status
- Source-of-truth hierarchy
- Migration upgrade graph health
- Data integrity status
- Primary persistence risks
## 2. Persistence Inventory
| Data | Storage | Authority | User-scoped | Durable | Risk |
|---|---|---|---|---|---|
## 3. Database Architecture
## 4. Schema Audit
## 5. Entity Audit
## 6. Primary / Unique Key Audit
## 7. Foreign Key / Relation Audit
## 8. DAO Correctness Audit
## 9. Query Audit
## 10. Index Audit
## 11. Transaction Audit
## 12. Concurrency / Atomicity Audit
## 13. Migration Audit
## 14. Migration Test Coverage
## 15. TypeConverter Audit
## 16. DataStore / SharedPreferences Audit
## 17. File Persistence Audit
## 18. Backup / Export Audit
## 19. Restore / Import Audit
## 20. Account Isolation Audit
## 21. Logout / Reset Audit
## 22. Offline / Sync Persistence
## 23. Retention / Cleanup Audit
## 24. Corruption / Recovery Audit
## 25. Persistence Performance Risks
## 26. Test Coverage
## 27. Findings Summary
| ID | Severity | Data | Storage | Problem | Confidence | Status |
|---|---|---|---|---|---|---|
## 28. P0 Findings
## 29. P1 Findings
## 30. P2 Findings
## 31. P3 Findings
## 32. P4 Improvements
## 33. Things Done Well
## 34. Unknown / Not Verified
## 35. Remediation Roadmap
---
# 194. DATABASE SCHEMA MATRIX
Construct:
| Table | PK | Unique | FK | Indexes | User scope | Growth |
|---|---|---|---|---|---|---|
---
# 195. MIGRATION MATRIX
| From | To | Migration exists | Schema tested | Data tested | Risk |
|---|---|---|---|---|---|
---
# 196. TRANSACTION MATRIX
| Business operation | Tables | Atomic required | Atomic actual | Risk |
|---|---|---|---|---|
---
# 197. ACCOUNT ISOLATION MATRIX
| Data | User key | Query filtered | Cleared on logout | Cross-user risk |
|---|---|---|---|---|
---
# 198. RETENTION MATRIX
| Data | Growth source | Retention policy | Cleanup | Unbounded |
|---|---|---|---|---|
---
# 199. BACKUP MATRIX
| Data source | Included | Restored | Versioned | Sensitive | Verified |
|---|---|---|---|---|---|
---
# 200. SECOND PASS - LEGACY USER UPGRADE
Simulate a user upgrading from one of the earliest supported database versions.
Include:
- Realistic legacy data records
- Null fields
- Complex relational entities
- Pending sync mutations
- Archived rows
Trace migrations step-by-step to the current schema.
Ask:
> Does the user retain semantically identical data in the new schema model?
---
# 201. SECOND PASS - PROCESS TERMINATION DURING WRITES
For each critical mutation:
```text
Operation begins
↓
First disk mutation committed
↓
OS terminates process
```
Ask:
- What state remains on disk
- Does the next app launch recognize the partial state
- Can the system cleanly recover without corruption
---
# 202. SECOND PASS - ACCOUNT SWITCHING CONCURRENCY
Simulate:
```text
User A populates Room
↓
Background sync begins
↓
User logs out
↓
User B logs in
↓
User A's sync finishes
```
Examine all storage layers for cross-user bleeding.
---
# 203. SECOND PASS - CONCURRENT WRITE DUPLICATION
Simulate concurrent dispatches of create, import, or sync tasks:
```text
Operation A
Operation B
```
Verify:
- Unique constraint enforcement
- Transaction isolation
- Upsert conflict handling
- Duplicate row prevention
---
# 204. SECOND PASS - DELETION RACE CONDITIONS
Scenario:
```text
Resource loaded in memory
↓
Background sync starts
↓
User deletes the resource
↓
Background sync completes
```
Can the resource be resurrected or leave orphaned child records?
---
# 205. SECOND PASS - DISK SPACE EXHAUSTION
Simulate write failures triggered by full disk storage.
Verify:
- Transaction rollback
- Proper error reporting to UI
- Prevention of corrupted partial files
---
# 206. SECOND PASS - LOCAL DATA CORRUPTION
Simulate:
- Corrupted JSON files
- Missing referenced files
- Malformed DataStore files
- SQLite database corruption
Ask:
> Does the application recover gracefully or enter an unrecoverable crash loop?
---
# 207. SECOND PASS - BACKUP AND RESTORE ROUNDTRIP
Trace:
```text
Complex user dataset
↓
Export backup
↓
Completely wipe application storage
↓
Import backup
```
Compare:
- Entities
- Relational joins
- Attached media files
- User preferences
- Pending sync states
---
# 208. SECOND PASS - LARGE DATABASE SCALING
Mentally scale database row counts by 10x.
Inspect critical queries for:
- Full table scans
- Sort operations
- Multi-table joins
- Cursor memory allocation
Align severity with realistic growth projections.
---
# 209. SECOND PASS - UNBOUNDED STORAGE RETENTION
Simulate multiple years of active usage.
Ask:
> Which table or file directory continues to grow without an upper bound?
---
# 210. SECOND PASS - PERSISTED VALUE COMPATIBILITY
For every persisted enum, status, or TypeConverter, ask:
> What happens when an identifier or structure changes across two releases?
---
# 211. SECOND PASS - MIGRATION EXCEPTION HANDLING
Ask:
> What occurs if a migration throws an exception on a production device?
Check:
- Crash loops
- Destructive fallback invocation
- Recovery mechanisms
- User data preservation
---
# 212. FINAL QUALITY GATE
Before submitting the final report, verify:
- The audit evaluated historical upgrade paths, not merely the current schema
- Migration tests are not assumed to prove semantic data correctness
- Destructive migrations explicitly classify affected data loss
- Core business invariants are enforced by database-level constraints
- Foreign key cascade policies are fully traced
- SQLite `REPLACE` and `IGNORE` semantics are rigorously analyzed
- Transaction findings demonstrate a concrete partial-state scenario
- Account isolation is verified across DAOs and logout routines
- Room cache is strictly distinguished from durable local data
- Backup matrices cover all declared storage domains
- Restore failure recovery is analyzed
- Cache directories are not treated as durable storage
- DataStore and SharedPreferences are evaluated by correctness, not API age
- Query performance findings include dataset and frequency context
- Index recommendations reference specific slow queries
- Unbounded storage growth is audited
- Genuine bugs and architectural improvements are strictly separated
---
# FINAL RULE
I do not want a generic report stating:
> Add indexes, use transactions, and write migration tests.
That is not a persistence audit.
I am looking for concrete issues such as:
```text
Database version is v2
↓
User upgrades directly to app with database v6
↓
Migrations exist only for 4 -> 5 and 5 -> 6
↓
Room cannot construct an upgrade path from v2 to v6
↓
Existing production user cannot open database and app crashes
```
or:
```text
Create order workflow
↓
Insert order row
↓
Insert line items sequentially
↓
Line item 4 throws an exception
↓
No enclosing transaction
↓
Database retains an incomplete, corrupt order record
```
or:
```text
User A logs out
↓
Auth token is cleared
↓
Room database rows remain intact
↓
User B logs in
↓
DAO query lacks a user_id predicate
↓
User A's private records are emitted to User B
```
or:
```text
Enum status is persisted as an ordinal
↓
New app release inserts a new enum constant in the middle
↓
Historical integer values now map to entirely different semantic meanings
↓
Existing production records silently change business states
```
or:
```text
Backup process begins
↓
Room database file is exported
↓
User edits an attachment while backup continues
↓
Media files are copied afterward
↓
Backup contains database metadata from state A and files from state B
↓
Restoring this backup produces internally inconsistent data
```
or:
```text
User-authored document is saved exclusively in context.cacheDir
↓
Android OS clears cache directory under storage pressure
↓
User's only copy of the document is permanently destroyed
```
or:
```text
if (!dao.exists(remoteId)) {
dao.insert(entity)
}
```
with two concurrent sync workers:
```text
Worker A evaluates false
Worker B evaluates false
Worker A inserts
Worker B inserts
↓
Duplicate rows created
```
because the table lacks a unique database constraint.
These are the concrete persistence defects you must uncover.
Think through:
- Schema history
- Semantic data preservation
- Upgrade graphs
- Transaction boundaries
- Database constraints
- Account data ownership
- Durability guarantees
- Recovery strategies
- Backup and restore consistency
- Concurrent mutations
- Long-term storage growth
For every serious finding, answer:
> What specific data is compromised?
> Is the data rebuildable cache or the sole copy?
> What exact database or file I/O sequence leads to the failure?
> Can an existing production user already possess the state required to trigger the bug?
> Does the fix require an SQLite schema migration?
> How does a regression test prove that data remains semantically identical?
If evidence is insufficient:
**NOT VERIFIED.**
If the issue is merely an architectural enhancement:
**P4 - IMPROVEMENT.**
If a migration runs successfully but data values were not verified:
**DATA SEMANTICS NOT VERIFIED.**
It is far better to find 5 genuine data-integrity defects than to produce 100 generic Room recommendations.
The objective is a forensically sound persistence audit that directly translates into:
- Robust schema migrations
- Database unique constraints
- Transactional integrity fixes
- Automated migration tests
- Reliable backup and restore flows
- Production data preservation plans分类与标签
编程开发、Android开发、Room数据库、数据迁移