返回提示词目录第 1511 页

审查安卓本地数据持久化实现

检查 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数据库、数据迁移

前往 AI 图片创作