Destructive migration

example/lib/database.dart

@@ -7,7 +7,7 @@ import 'package:sqflite/sqflite.dart' as sqflite;
 
 part 'database.g.dart';
 
-@Database(version: 1, entities: [Task])
+@Database(version: 1, entities: [Task], fallbackToDestructiveMigration: false)
 abstract class FlutterDatabase extends FloorDatabase {
   TaskDao get taskDao;
 }

floor/lib/src/adapter/migration_adapter.dart

@@ -1,6 +1,8 @@
 import 'package:floor/src/migration.dart';
 import 'package:sqflite/sqflite.dart';
 
+class MissingMigrationException implements Exception {}
+
 abstract class MigrationAdapter {
   /// Runs the given [migrations] for migrating the database schema and data.
   static Future<void> runMigrations(
@@ -17,10 +19,7 @@ abstract class MigrationAdapter {
 
     if (relevantMigrations.isEmpty ||
         relevantMigrations.last.endVersion != endVersion) {
-      throw StateError(
-        'There is no migration supplied to update the database to the current version.'
-        ' Aborting the migration.',
-      );
+      throw MissingMigrationException();
     }
 
     for (final migration in relevantMigrations) {

floor/lib/src/callback.dart

@@ -25,7 +25,30 @@ class Callback {
     int endVersion,
   )? onUpgrade;
 
+  /// Fired when the [database] failed upgrading caused by [exception] from
+  /// [startVersion] to [endVersion], before dropping all existing data and re-creating the schema.
+  final FutureOr<void> Function(
+    Database database,
+    int startVersion,
+    int endVersion,
+    Exception exception,
+  )? onDestructiveUpgrade;
+
+  /// Fired when the [database] is downgrading from [startVersion] to
+  /// [endVersion], before dropping all existing data and re-creating the schema.
+  final FutureOr<void> Function(
+    Database database,
+    int startVersion,
+    int endVersion,
+  )? onDestructiveDowngrade;
+
   /// Constructor.
-  const Callback(
-      {this.onConfigure, this.onCreate, this.onOpen, this.onUpgrade});
+  const Callback({
+    this.onConfigure,
+    this.onCreate,
+    this.onOpen,
+    this.onUpgrade,
+    this.onDestructiveUpgrade,
+    this.onDestructiveDowngrade,
+  });
 }

floor/test/adapter/migration_adapter_test.dart

@@ -86,7 +86,7 @@ void main() {
           migrations,
         );
 
-    expect(actual, throwsStateError);
+    expect(actual, throwsException);
     verifyZeroInteractions(mockDatabase);
   });
 
@@ -107,7 +107,7 @@ void main() {
           migrations,
         );
 
-    expect(actual, throwsStateError);
+    expect(actual, throwsException);
     verifyZeroInteractions(mockDatabase);
   });
 }

floor_annotation/lib/src/database.dart

@@ -9,10 +9,14 @@ class Database {
   /// The views the database manages.
   final List<Type> views;
 
+  // Re-create the database if migration fails or is missing.
+  final bool fallbackToDestructiveMigration;
+
   /// Marks a class as a FloorDatabase.
   const Database({
     required this.version,
     required this.entities,
+    this.fallbackToDestructiveMigration = false,
     this.views = const [],
   });
 }

floor_generator/lib/misc/constants.dart

@@ -6,6 +6,8 @@ abstract class AnnotationField {
   static const databaseVersion = 'version';
   static const databaseEntities = 'entities';
   static const databaseViews = 'views';
+  static const databaseFallbackToDestructiveMigration =
+      'fallbackToDestructiveMigration';
 
   static const columnInfoName = 'name';
 

floor_generator/lib/processor/database_processor.dart

@@ -53,6 +53,7 @@ class DatabaseProcessor extends Processor<Database> {
       daoGetters,
       version,
       databaseTypeConverters,
+      _getFallBackToDestruction(),
       allTypeConverters,
     );
   }
@@ -178,4 +179,13 @@ class DatabaseProcessor extends Processor<Database> {
     return classElement.hasAnnotation(annotations.DatabaseView) &&
         !classElement.isAbstract;
   }
+
+  bool _getFallBackToDestruction() {
+    final isDestructive = _classElement
+        .getAnnotation(annotations.Database)
+        ?.getField(AnnotationField.databaseFallbackToDestructiveMigration)
+        ?.toBoolValue();
+
+    return isDestructive ?? false;
+  }
 }

floor_generator/lib/value_object/database.dart

@@ -16,6 +16,7 @@ class Database {
   final int version;
   final Set<TypeConverter> databaseTypeConverters;
   final Set<TypeConverter> allTypeConverters;
+  final bool fallbackToDestructiveMigration;
   final bool hasViewStreams;
   final Set<Entity> streamEntities;
 
@@ -27,6 +28,7 @@ class Database {
     this.daoGetters,
     this.version,
     this.databaseTypeConverters,
+    this.fallbackToDestructiveMigration,
     this.allTypeConverters,
   )   : streamEntities =
             daoGetters.expand((dg) => dg.dao.streamEntities).toSet(),
@@ -45,6 +47,8 @@ class Database {
           version == other.version &&
           databaseTypeConverters.equals(other.databaseTypeConverters) &&
           allTypeConverters.equals(other.allTypeConverters) &&
+          fallbackToDestructiveMigration ==
+              other.fallbackToDestructiveMigration &&
           streamEntities.equals(other.streamEntities) &&
           hasViewStreams == hasViewStreams;
 
@@ -58,11 +62,12 @@ class Database {
       version.hashCode ^
       databaseTypeConverters.hashCode ^
       allTypeConverters.hashCode ^
+      fallbackToDestructiveMigration.hashCode ^
       streamEntities.hashCode ^
       hasViewStreams.hashCode;
 
   @override
   String toString() {
-    return 'Database{classElement: $classElement, name: $name, entities: $entities, views: $views, daoGetters: $daoGetters, version: $version, databaseTypeConverters: $databaseTypeConverters, allTypeConverters: $allTypeConverters, streamEntities: $streamEntities, hasViewStreams: $hasViewStreams}';
+    return 'Database{classElement: $classElement, name: $name, entities: $entities, views: $views, daoGetters: $daoGetters, version: $version, databaseTypeConverters: $databaseTypeConverters, $version,isFallBackToDestruction: $fallbackToDestructiveMigration, allTypeConverters: $allTypeConverters, streamEntities: $streamEntities, hasViewStreams: $hasViewStreams}';
   }
 }

floor_generator/lib/writer/database_writer.dart

@@ -19,13 +19,16 @@ class DatabaseWriter implements Writer {
   Class _generateDatabaseImplementation(final Database database) {
     final databaseName = database.name;
 
-    return Class((builder) => builder
-      ..name = '_\$$databaseName'
-      ..extend = refer(databaseName)
-      ..methods.add(_generateOpenMethod(database))
-      ..methods.addAll(_generateDaoGetters(database))
-      ..fields.addAll(_generateDaoInstances(database))
-      ..constructors.add(_generateConstructor()));
+    return Class((builder) {
+      builder
+        ..name = '_\$$databaseName'
+        ..extend = refer(databaseName)
+        ..methods.add(_generateOpenMethod(database))
+        ..methods.add(_generateCreateMethod(database))
+        ..methods.addAll(_generateDaoGetters(database))
+        ..fields.addAll(_generateDaoInstances(database))
+        ..constructors.add(_generateConstructor());
+    });
   }
 
   Constructor _generateConstructor() {
@@ -68,21 +71,40 @@ class DatabaseWriter implements Writer {
     }).toList();
   }
 
-  Method _generateOpenMethod(final Database database) {
+  Method _generateCreateMethod(final Database database) {
+    final databaseParameter = Parameter((builder) => builder
+      ..name = 'database'
+      ..type = refer('sqflite.Database'));
+
     final createTableStatements = _generateCreateTableSqlStatements(
             database.entities)
         .map((statement) => 'await database.execute(${statement.toLiteral()});')
         .join('\n');
+
     final createIndexStatements = database.entities
         .map((entity) => entity.indices.map((index) => index.createQuery()))
         .expand((statements) => statements)
         .map((statement) => 'await database.execute(${statement.toLiteral()});')
         .join('\n');
+
     final createViewStatements = database.views
         .map((view) => view.getCreateViewStatement().toLiteral())
         .map((statement) => 'await database.execute($statement);')
         .join('\n');
 
+    return Method((builder) => builder
+      ..name = '_create'
+      ..returns = refer('Future<void>')
+      ..requiredParameters.add(databaseParameter)
+      ..modifier = MethodModifier.async
+      ..body = Code('''
+          $createTableStatements
+          $createIndexStatements
+          $createViewStatements
+          '''));
+  }
+
+  Method _generateOpenMethod(final Database database) {
     final pathParameter = Parameter((builder) => builder
       ..name = 'path'
       ..type = refer('String'));
@@ -93,13 +115,59 @@ class DatabaseWriter implements Writer {
       ..name = 'callback'
       ..type = refer('Callback?'));
 
-    return Method((builder) => builder
-      ..name = 'open'
-      ..returns = refer('Future<sqflite.Database>')
-      ..modifier = MethodModifier.async
-      ..requiredParameters.addAll([pathParameter, migrationsParameter])
-      ..optionalParameters.add(callbackParameter)
-      ..body = Code('''
+    String body;
+
+    if (database.fallbackToDestructiveMigration) {
+      body = '''
+        bool shouldDeleteDatabase = false;
+
+        final databaseOptions = sqflite.OpenDatabaseOptions(
+          version: ${database.version},
+          onConfigure: (database) async {
+            await database.execute('PRAGMA foreign_keys = ON');
+            await callback?.onConfigure?.call(database);
+          },
+          onOpen: (database) async {
+            await callback?.onOpen?.call(database);
+          },
+          onUpgrade: (database, startVersion, endVersion) async {
+            try {
+              await MigrationAdapter.runMigrations(
+                database,
+                startVersion,
+                endVersion,
+                migrations,
+              );
+              await callback?.onUpgrade?.call(database, startVersion, endVersion);
+            } on Exception catch (e) {
+              await callback?.onDestructiveUpgrade?.call(database, startVersion, endVersion, e);
+              shouldDeleteDatabase = true;
+            }
+          },
+          onDowngrade: (database, startVersion, endVersion) async {
+            await callback?.onDestructiveDowngrade?.call(database, startVersion, endVersion);
+            shouldDeleteDatabase = true;
+          },
+          onCreate: (database, version) async {
+            await _create(database);
+            await callback?.onCreate?.call(database, version);
+          },
+        );
+
+        final database = await sqfliteDatabaseFactory.openDatabase(path,
+            options: databaseOptions);
+
+        if (shouldDeleteDatabase) {
+          await database.close();
+          await sqfliteDatabaseFactory.deleteDatabase(path);
+          return sqfliteDatabaseFactory.openDatabase(path,
+              options: databaseOptions);
+        } else {
+          return database;
+        }
+      ''';
+    } else {
+      body = '''
           final databaseOptions = sqflite.OpenDatabaseOptions(
             version: ${database.version},
             onConfigure: (database) async {
@@ -110,20 +178,37 @@ class DatabaseWriter implements Writer {
               await callback?.onOpen?.call(database);
             },
             onUpgrade: (database, startVersion, endVersion) async {
-              await MigrationAdapter.runMigrations(database, startVersion, endVersion, migrations);
-
+              try {
+                await MigrationAdapter.runMigrations(
+                  database, 
+                  startVersion,
+                  endVersion,
+                  migrations,
+                );
+              } on MissingMigrationException catch (_) {
+                throw StateError(
+                  'There is no migration supplied to update the database to the current version.'
+                  ' Aborting the migration.',
+                );
+              }
               await callback?.onUpgrade?.call(database, startVersion, endVersion);
             },
             onCreate: (database, version) async {
-              $createTableStatements
-              $createIndexStatements
-              $createViewStatements
-
+              await _create(database);
               await callback?.onCreate?.call(database, version);
             },
           );
           return sqfliteDatabaseFactory.openDatabase(path, options: databaseOptions);
-          '''));
+          ''';
+    }
+
+    return Method((builder) => builder
+      ..name = 'open'
+      ..returns = refer('Future<sqflite.Database>')
+      ..modifier = MethodModifier.async
+      ..requiredParameters.addAll([pathParameter, migrationsParameter])
+      ..optionalParameters.add(callbackParameter)
+      ..body = Code(body));
   }
 
   List<String> _generateCreateTableSqlStatements(final List<Entity> entities) {