@@ -128,11 +128,11 @@ object LocationTrackStore {
             // Before the table exists: set afterwards it is a no-op until a full
             // VACUUM, and without it deleted rows free pages inside the file and
             // never give the bytes back to the budget.
-            handle.execSQL("PRAGMA auto_vacuum=INCREMENTAL")
-            handle.execSQL("PRAGMA journal_mode=WAL")
+            queryPragma(handle, "PRAGMA auto_vacuum=INCREMENTAL")
+            queryPragma(handle, "PRAGMA journal_mode=WAL")
             // A fix lost to a power cut is one point on a track; a blocked fsync
             // inside a background wake can cost the report as well.
-            handle.execSQL("PRAGMA synchronous=NORMAL")
+            queryPragma(handle, "PRAGMA synchronous=NORMAL")
             handle.execSQL(
                 """
                 CREATE TABLE IF NOT EXISTS fix (
@@ -152,6 +152,25 @@ object LocationTrackStore {
 
     private data class Fix(val t: Long, val lat: Long, val lng: Long)
 
+    /**
+     * Runs a PRAGMA that returns a row, and reads that row.
+     *
+     * [SQLiteDatabase.execSQL] rejects a statement that produces a result.
+     * `PRAGMA journal_mode=WAL` does — it answers with the mode it just set —
+     * and Android throws "Queries can be performed using SQLiteDatabase query
+     * or rawQuery methods only." [open] caught that and returned null, but
+     * [SQLiteDatabase.openOrCreateDatabase] had already created the file, so
+     * the `fix` table was never created. The Dart reader then opened a
+     * database with no table and reported `no such table: fix`, and every
+     * later fix failed the same way: the history stayed empty.
+     *
+     * The cursor has to be stepped. A query that is never read is a query
+     * that may not have run.
+     */
+    private fun queryPragma(handle: SQLiteDatabase, sql: String) {
+        handle.rawQuery(sql, null).use { it.moveToFirst() }
+    }
+
     private fun scalar(handle: SQLiteDatabase, sql: String): Long =
         handle.rawQuery(sql, null).use { if (it.moveToFirst()) it.getLong(0) else 0L }
 
 
@@ -128,6 +128,8 @@ class LocationTrack {
   /// file costs disk.
   Future<List<TrackFix>> since(DateTime from, {int? limit}) async {
     try {
+      // No table is an empty history. See [_fixTableQuery].
+      if (!await _hasFixTable()) return const [];
       final start = await _anchorAtOrBefore(from);
       final fixes = await _decodeFrom(start);
       final wanted = fixes.where((fix) => !fix.time.isBefore(from)).toList();
@@ -152,6 +154,15 @@ class LocationTrack {
   /// reading the decoder gives it.
   Future<({int fixes, int bytes, DateTime? oldest})> stats() async {
     try {
+      // See [_fixTableQuery]: no table is an empty history, not a crash.
+      if (!await _hasFixTable()) {
+        final file = File(_path);
+        return (
+          fixes: 0,
+          bytes: file.existsSync() ? file.lengthSync() : 0,
+          oldest: null,
+        );
+      }
       final row = await _db.get('SELECT COUNT(*) AS n FROM fix');
       final first = await _db.getOptional(
         'SELECT t FROM fix ORDER BY id LIMIT 1',
@@ -195,6 +206,9 @@ class LocationTrack {
     if (!File(path).existsSync()) return;
     final db = sqlite3.open(path, mode: OpenMode.readOnly);
     try {
+      // See [_fixTableQuery]. Throwing here is how the digest becomes a
+      // crash report.
+      if (db.select(_fixTableQuery).isEmpty) return;
       final fromMs = from.millisecondsSinceEpoch;
       final anchor = db.select(_anchorQuery, [fromMs ~/ 1000]);
       final start = anchor.isEmpty
@@ -225,6 +239,20 @@ class LocationTrack {
     }
   }
 
+  /// A file with no `fix` table is an empty history, the same answer as no
+  /// file.
+  ///
+  /// Android creates the file in `openOrCreateDatabase` and only then runs
+  /// the pragmas and `CREATE TABLE`. `execSQL` rejects
+  /// `PRAGMA journal_mode=WAL` because that pragma returns a row; the
+  /// exception was swallowed and the table was never created, so every read
+  /// reported `no such table: fix`.
+  static const _fixTableQuery =
+      "SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = 'fix'";
+
+  Future<bool> _hasFixTable() async =>
+      (await _db.getOptional(_fixTableQuery)) != null;
+
   /// The newest anchor at or before an instant (see [_anchorAtOrBefore]).
   static const _anchorQuery =
       'SELECT id FROM fix WHERE id % $_anchorEvery = 0 AND t <= ? '
 
@@ -12,6 +12,8 @@ library;
 import 'dart:io';
 
 import 'package:dpip/core/geo/location_track.dart';
+import 'package:dpip/core/logging/crash_sink.dart';
+import 'package:dpip/core/logging/log.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:sqlite3/sqlite3.dart' as sqlite3;
 
@@ -38,6 +40,35 @@ void main() {
     expect(LocationTrack.at(path), isNull);
   });
 
+  test(
+    'a database with no fix table is an empty history, not a crash',
+    () async {
+      // What Android left behind: openOrCreateDatabase created the file, then
+      // execSQL("PRAGMA journal_mode=WAL") threw before CREATE TABLE. The
+      // pragma writes the header, so the file is a database and not empty.
+      final created = sqlite3.sqlite3.open(path);
+      created.execute('PRAGMA user_version = 0');
+      created.close();
+      final track = LocationTrack.at(path)!;
+      addTearDown(track.close);
+
+      final sink = _RecordingSink();
+      Log.crashSink = sink;
+      addTearDown(() => Log.crashSink = null);
+
+      final stats = await track.stats();
+      expect(stats.fixes, 0);
+      expect(stats.oldest, isNull);
+      expect(stats.bytes, greaterThan(0));
+      expect(await track.since(DateTime.utc(2000)), isEmpty);
+
+      final visited = <int>[];
+      LocationTrack.scan(path, DateTime.utc(2000), (t, _, _) => visited.add(t));
+      expect(visited, isEmpty);
+      expect(sink.reports, isEmpty);
+    },
+  );
+
   test('a single fix round-trips', () async {
     writeTrackFixture(path, [(1735689600, 25.0330, 121.5654)]);
     final track = LocationTrack.at(path)!;
@@ -267,3 +298,17 @@ void main() {
     );
   });
 }
+
+class _RecordingSink implements CrashSink {
+  final List<Object> reports = [];
+
+  @override
+  void report(
+    Object error,
+    StackTrace stackTrace, {
+    String? context,
+    bool fatal = false,
+  }) {
+    reports.add(error);
+  }
+}