diff --git a/room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/migration/MigrationTest.java b/room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/migration/MigrationTest.java
index 60b5462..7927944 100644
--- a/room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/migration/MigrationTest.java
+++ b/room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/migration/MigrationTest.java
@@ -38,6 +38,7 @@
 import androidx.room.util.TableInfo;
 import androidx.room.util.ViewInfo;
 import androidx.sqlite.db.SupportSQLiteDatabase;
+import androidx.sqlite.db.SupportSQLiteOpenHelper;
 import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
@@ -562,6 +563,37 @@
         }
     }
 
+    // Verifies that even with allowDataLossOnRecovery, bad migrations are propagated and the DB
+    // is not silently deleted.
+    @Test
+    public void badMigration_allowDataLossOnRecovery() throws IOException {
+        // Create DB at version 1
+        helper.createDatabase(TEST_DB, 1).close();
+
+        // Create DB at latest version, but no migrations and with allowDataLossOnRecovery, it
+        // should fail to open.
+        Context targetContext = ApplicationProvider.getApplicationContext();
+        MigrationDb db = Room.databaseBuilder(targetContext, MigrationDb.class, TEST_DB)
+                .openHelperFactory(configuration -> {
+                    SupportSQLiteOpenHelper.Configuration config =
+                            SupportSQLiteOpenHelper.Configuration.builder(targetContext)
+                                    .name(configuration.name)
+                                    .callback(configuration.callback)
+                                    .allowDataLossOnRecovery(true)
+                                    .build();
+                    return new FrameworkSQLiteOpenHelperFactory().create(config);
+                })
+                .build();
+        try {
+            db.getOpenHelper().getWritableDatabase();
+            Assert.fail("Expected a missing migration exception");
+        } catch (IllegalStateException ex) {
+            // Verifies exception is not wrapped
+            Truth.assertThat(ex).hasMessageThat()
+                    .containsMatch("A migration from \\d+ to \\d+ was required but not found.");
+        }
+    }
+
     private void testFailure(int startVersion, int endVersion) throws IOException {
         final SupportSQLiteDatabase db = helper.createDatabase(TEST_DB, startVersion);
         db.close();
diff --git a/sqlite/sqlite-framework/build.gradle b/sqlite/sqlite-framework/build.gradle
index 8e92837..9dfb2cf 100644
--- a/sqlite/sqlite-framework/build.gradle
+++ b/sqlite/sqlite-framework/build.gradle
@@ -19,11 +19,20 @@
 plugins {
     id("AndroidXPlugin")
     id("com.android.library")
+    id("org.jetbrains.kotlin.android")
 }
 
 dependencies {
     api("androidx.annotation:annotation:1.2.0")
     api(project(":sqlite:sqlite"))
+    androidTestImplementation(libs.kotlinStdlib)
+    androidTestImplementation(libs.testExtJunit)
+    androidTestImplementation(libs.testCore)
+    androidTestImplementation(libs.testRunner) {
+        exclude module: "support-annotations"
+        exclude module: "hamcrest-core"
+    }
+    androidTestImplementation(libs.truth)
 }
 
 androidx {
diff --git a/sqlite/sqlite-framework/src/androidTest/java/androidx/sqlite/db/framework/OpenHelperRecoveryTest.kt b/sqlite/sqlite-framework/src/androidTest/java/androidx/sqlite/db/framework/OpenHelperRecoveryTest.kt
new file mode 100644
index 0000000..2ff6161
--- /dev/null
+++ b/sqlite/sqlite-framework/src/androidTest/java/androidx/sqlite/db/framework/OpenHelperRecoveryTest.kt
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.sqlite.db.framework
+
+import android.content.Context
+import android.database.sqlite.SQLiteException
+import androidx.sqlite.db.SupportSQLiteDatabase
+import androidx.sqlite.db.SupportSQLiteOpenHelper
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.filters.LargeTest
+import com.google.common.truth.Truth.assertThat
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+
+@LargeTest
+class OpenHelperRecoveryTest {
+
+    private val dbName = "test.db"
+    private val context: Context = ApplicationProvider.getApplicationContext()
+
+    @Before
+    fun setup() {
+        context.deleteDatabase(dbName)
+    }
+
+    @Test
+    fun writeOver() {
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, EmptyCallback(), false, false)
+        openHelper.writableDatabase.use { db ->
+            db.execSQL("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+            db.query("SELECT * FROM sqlite_master WHERE name = 'Foo'").use {
+                assertThat(it.count).isEqualTo(1)
+            }
+        }
+
+        val dbFile = context.getDatabasePath(dbName)
+        assertThat(dbFile.exists()).isTrue()
+        assertThat(dbFile.length()).isGreaterThan(0)
+        dbFile.writeText("malas vibra")
+
+        try {
+            openHelper.writableDatabase
+            fail("Database should have failed to open.")
+        } catch (ex: SQLiteException) {
+            // Expected
+        }
+    }
+
+    @Test
+    fun writeOver_allowDataLossOnRecovery() {
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, EmptyCallback(), false, true)
+        openHelper.writableDatabase.use { db ->
+            db.execSQL("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+            db.query("SELECT * FROM sqlite_master WHERE name = 'Foo'").use {
+                assertThat(it.count).isEqualTo(1)
+            }
+        }
+
+        val dbFile = context.getDatabasePath(dbName)
+        assertThat(dbFile.exists()).isTrue()
+        assertThat(dbFile.length()).isGreaterThan(0)
+        dbFile.writeText("malas vibra")
+
+        openHelper.writableDatabase.use { db ->
+            db.query("SELECT * FROM sqlite_master WHERE name = 'Foo'").use {
+                assertThat(it.count).isEqualTo(0)
+            }
+        }
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onCreateError() {
+        var createAttempts = 0
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {
+                if (createAttempts++ < 2) {
+                    throw RuntimeException("Not an SQLiteException")
+                }
+            }
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {}
+        }
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        try {
+            openHelper.writableDatabase
+            fail("Database should have failed to open.")
+        } catch (ex: RuntimeException) {
+            // Expected
+            assertThat(ex.message).contains("Not an SQLiteException")
+        }
+        assertThat(createAttempts).isEqualTo(2)
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onUpgradeError() {
+        // Create DB at version 1, open and close it
+        FrameworkSQLiteOpenHelper(context, dbName, EmptyCallback(1), false, true).let {
+            it.writableDatabase.close()
+        }
+
+        // A callback to open DB at version 2, it has a bad migration.
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(2) {
+            override fun onCreate(db: SupportSQLiteDatabase) {}
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
+                db.execSQL("SELECT * FROM bad_table")
+            }
+        }
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        try {
+            openHelper.writableDatabase
+            fail("Database should have failed to open.")
+        } catch (ex: SQLiteException) {
+            // Expected
+            assertThat(ex.message).contains("no such table: bad_table")
+        }
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onOpenNonSQLiteError() {
+        var openAttempts = 0
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {}
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {}
+            override fun onOpen(db: SupportSQLiteDatabase) {
+                if (openAttempts++ < 2) {
+                    throw RuntimeException("Not an SQLiteException")
+                }
+            }
+        }
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        try {
+            openHelper.writableDatabase
+            fail("Database should have failed to open.")
+        } catch (ex: RuntimeException) {
+            // Expected
+            assertThat(ex.message).contains("Not an SQLiteException")
+        }
+        assertThat(openAttempts).isEqualTo(2)
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onOpenSQLiteError_intermediate() {
+        FrameworkSQLiteOpenHelper(context, dbName, EmptyCallback(), false, false)
+            .writableDatabase.use { db ->
+                db.execSQL("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+            }
+
+        var openAttempts = 0
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {}
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {}
+            override fun onOpen(db: SupportSQLiteDatabase) {
+                if (openAttempts++ < 1) {
+                    db.execSQL("SELECT * FROM bad_table")
+                }
+            }
+        }
+        // With only 1 onOpen error, the database is opened without being deleted, simulates an
+        // intermediate error.
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        openHelper.writableDatabase.use { db ->
+            db.query("SELECT * FROM sqlite_master WHERE name = 'Foo'").use {
+                assertThat(it.count).isEqualTo(1)
+            }
+        }
+        assertThat(openAttempts).isEqualTo(2)
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onOpenSQLiteError_recoverable() {
+        FrameworkSQLiteOpenHelper(context, dbName, EmptyCallback(), false, false)
+            .writableDatabase.use { db ->
+                db.execSQL("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+            }
+
+        var openAttempts = 0
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {}
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {}
+            override fun onOpen(db: SupportSQLiteDatabase) {
+                if (openAttempts++ < 2) {
+                    db.execSQL("SELECT * FROM bad_table")
+                }
+            }
+        }
+        // With 2 onOpen error, the database is opened by deleting it, simulating a recoverable
+        // error.
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        openHelper.writableDatabase.use { db ->
+            db.query("SELECT * FROM sqlite_master WHERE name = 'Foo'").use {
+                assertThat(it.count).isEqualTo(0)
+            }
+        }
+        assertThat(openAttempts).isEqualTo(3)
+    }
+
+    @Test
+    fun allowDataLossOnRecovery_onOpenSQLiteError_permanent() {
+        var openAttempts = 0
+        val badCallback = object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {}
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {}
+            override fun onOpen(db: SupportSQLiteDatabase) {
+                openAttempts++
+                db.execSQL("SELECT * FROM bad_table")
+            }
+        }
+        // Consistent onOpen error, might be a user bug or an actual SQLite permanent error,
+        // nothing we can do here, expect failure
+        val openHelper = FrameworkSQLiteOpenHelper(context, dbName, badCallback, false, true)
+        try {
+            openHelper.writableDatabase
+            fail("Database should have failed to open.")
+        } catch (ex: SQLiteException) {
+            // Expected
+            assertThat(ex.message).contains("no such table: bad_table")
+        }
+        assertThat(openAttempts).isEqualTo(3)
+    }
+
+    class EmptyCallback(version: Int = 1) : SupportSQLiteOpenHelper.Callback(version) {
+        override fun onCreate(db: SupportSQLiteDatabase) {
+        }
+
+        override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) {
+        }
+
+        override fun onOpen(db: SupportSQLiteDatabase) {
+        }
+
+        override fun onCorruption(db: SupportSQLiteDatabase) {
+        }
+    }
+}
\ No newline at end of file
diff --git a/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelper.java b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelper.java
index b3f6a12..7a76b70 100644
--- a/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelper.java
+++ b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelper.java
@@ -19,24 +19,31 @@
 import android.content.Context;
 import android.database.DatabaseErrorHandler;
 import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.os.Build;
+import android.util.Log;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;
 import androidx.sqlite.db.SupportSQLiteCompat;
 import androidx.sqlite.db.SupportSQLiteDatabase;
 import androidx.sqlite.db.SupportSQLiteOpenHelper;
 import androidx.sqlite.util.ProcessLock;
+import androidx.sqlite.util.SneakyThrow;
 
 import java.io.File;
 import java.util.UUID;
 
 class FrameworkSQLiteOpenHelper implements SupportSQLiteOpenHelper {
 
+    private static final String TAG = "SupportSQLite";
+
     private final Context mContext;
     private final String mName;
     private final Callback mCallback;
     private final boolean mUseNoBackupDirectory;
+    private final boolean mAllowDataLossOnRecovery;
     private final Object mLock;
 
     // Delegate is created lazily
@@ -55,10 +62,20 @@
             String name,
             Callback callback,
             boolean useNoBackupDirectory) {
+        this(context, name, callback, useNoBackupDirectory, false);
+    }
+
+    FrameworkSQLiteOpenHelper(
+            Context context,
+            String name,
+            Callback callback,
+            boolean useNoBackupDirectory,
+            boolean allowDataLossOnRecovery) {
         mContext = context;
         mName = name;
         mCallback = callback;
         mUseNoBackupDirectory = useNoBackupDirectory;
+        mAllowDataLossOnRecovery = allowDataLossOnRecovery;
         mLock = new Object();
     }
 
@@ -80,9 +97,11 @@
                             SupportSQLiteCompat.Api21Impl.getNoBackupFilesDir(mContext),
                             mName
                     );
-                    mDelegate = new OpenHelper(mContext, file.getAbsolutePath(), dbRef, mCallback);
+                    mDelegate = new OpenHelper(mContext, file.getAbsolutePath(), dbRef, mCallback,
+                            mAllowDataLossOnRecovery);
                 } else {
-                    mDelegate = new OpenHelper(mContext, mName, dbRef, mCallback);
+                    mDelegate = new OpenHelper(mContext, mName, dbRef, mCallback,
+                            mAllowDataLossOnRecovery);
                 }
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                     SupportSQLiteCompat.Api16Impl.setWriteAheadLoggingEnabled(mDelegate,
@@ -111,12 +130,12 @@
 
     @Override
     public SupportSQLiteDatabase getWritableDatabase() {
-        return getDelegate().getWritableSupportDatabase();
+        return getDelegate().getSupportDatabase(true);
     }
 
     @Override
     public SupportSQLiteDatabase getReadableDatabase() {
-        return getDelegate().getReadableSupportDatabase();
+        return getDelegate().getSupportDatabase(false);
     }
 
     @Override
@@ -131,7 +150,9 @@
          * constructor.
          */
         final FrameworkSQLiteDatabase[] mDbRef;
+        final Context mContext;
         final Callback mCallback;
+        final boolean mAllowDataLossOnRecovery;
         // see b/78359448
         private boolean mMigrated;
         // see b/193182592
@@ -139,7 +160,7 @@
         private boolean mOpened;
 
         OpenHelper(Context context, String name, final FrameworkSQLiteDatabase[] dbRef,
-                final Callback callback) {
+                final Callback callback, boolean allowDataLossOnRecovery) {
             super(context, name, null, callback.version,
                     new DatabaseErrorHandler() {
                         @Override
@@ -147,21 +168,23 @@
                             callback.onCorruption(getWrappedDb(dbRef, dbObj));
                         }
                     });
+            mContext = context;
             mCallback = callback;
             mDbRef = dbRef;
+            mAllowDataLossOnRecovery = allowDataLossOnRecovery;
             mLock = new ProcessLock(name == null ? UUID.randomUUID().toString() : name,
                     context.getCacheDir(), false);
         }
 
-        SupportSQLiteDatabase getWritableSupportDatabase() {
+        SupportSQLiteDatabase getSupportDatabase(boolean writable) {
             try {
                 mLock.lock(!mOpened && getDatabaseName() != null);
                 mMigrated = false;
-                SQLiteDatabase db = super.getWritableDatabase();
+                final SQLiteDatabase db = innerGetDatabase(writable);
                 if (mMigrated) {
                     // there might be a connection w/ stale structure, we should re-open.
                     close();
-                    return getWritableSupportDatabase();
+                    return getSupportDatabase(writable);
                 }
                 return getWrappedDb(db);
             } finally {
@@ -169,19 +192,87 @@
             }
         }
 
-        SupportSQLiteDatabase getReadableSupportDatabase() {
-            try {
-                mLock.lock(!mOpened && getDatabaseName() != null);
-                mMigrated = false;
-                SQLiteDatabase db = super.getReadableDatabase();
-                if (mMigrated) {
-                    // there might be a connection w/ stale structure, we should re-open.
-                    close();
-                    return getReadableSupportDatabase();
+        private SQLiteDatabase innerGetDatabase(boolean writable) {
+            String name = getDatabaseName();
+            if (name != null) {
+                File databaseFile = mContext.getDatabasePath(name);
+                File parentFile = databaseFile.getParentFile();
+                if (parentFile != null) {
+                    parentFile.mkdirs();
+                    if (!parentFile.isDirectory()) {
+                        Log.w(TAG, "Invalid database parent file, not a directory: " + parentFile);
+                    }
                 }
-                return getWrappedDb(db);
-            } finally {
-                mLock.unlock();
+            }
+
+            try {
+                return getWritableOrReadableDatabase(writable);
+            } catch (Throwable t) {
+                // No good, just try again...
+                super.close();
+            }
+
+            try {
+                // Wait before trying to open the DB, ideally enough to account for some slow I/O.
+                // Similar to android_database_SQLiteConnection's BUSY_TIMEOUT_MS but not as much.
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                // Ignore, and continue
+            }
+
+            final Throwable openRetryError;
+            try {
+                return getWritableOrReadableDatabase(writable);
+            } catch (Throwable t) {
+                super.close();
+                openRetryError = t;
+            }
+            if (openRetryError instanceof CallbackException) {
+                // Callback error (onCreate, onUpgrade, onOpen, etc), possibly user error.
+                final CallbackException callbackException = (CallbackException) openRetryError;
+                final Throwable cause = callbackException.getCause();
+                switch (callbackException.getCallbackName()) {
+                    case ON_CONFIGURE:
+                    case ON_CREATE:
+                    case ON_UPGRADE:
+                    case ON_DOWNGRADE:
+                        SneakyThrow.reThrow(cause);
+                        break;
+                    case ON_OPEN:
+                    default:
+                        break;
+                }
+                // If callback exception is not an SQLiteException, then more certainly it is not
+                // recoverable.
+                if (!(cause instanceof SQLiteException)) {
+                    SneakyThrow.reThrow(cause);
+                }
+            } else if (openRetryError instanceof SQLiteException) {
+                // Ideally we are looking for SQLiteCantOpenDatabaseException and similar, but
+                // corruption can manifest in others forms.
+                if (name == null || !mAllowDataLossOnRecovery) {
+                    SneakyThrow.reThrow(openRetryError);
+                }
+            } else {
+                SneakyThrow.reThrow(openRetryError);
+            }
+
+            // Delete the database and try one last time. (mAllowDataLossOnRecovery == true)
+            mContext.deleteDatabase(name);
+            try {
+                return getWritableOrReadableDatabase(writable);
+            } catch (CallbackException ex) {
+                // Unwrap our exception to avoid disruption with other try-catch in the call stack.
+                SneakyThrow.reThrow(ex.getCause());
+                return null; // Unreachable code, but compiler doesn't know it.
+            }
+        }
+
+        private SQLiteDatabase getWritableOrReadableDatabase(boolean writable) {
+            if (writable) {
+                return super.getWritableDatabase();
+            } else {
+                return super.getReadableDatabase();
             }
         }
 
@@ -191,31 +282,51 @@
 
         @Override
         public void onCreate(SQLiteDatabase sqLiteDatabase) {
-            mCallback.onCreate(getWrappedDb(sqLiteDatabase));
+            try {
+                mCallback.onCreate(getWrappedDb(sqLiteDatabase));
+            } catch (Throwable t) {
+                throw new CallbackException(CallbackName.ON_CREATE, t);
+            }
         }
 
         @Override
         public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
             mMigrated = true;
-            mCallback.onUpgrade(getWrappedDb(sqLiteDatabase), oldVersion, newVersion);
+            try {
+                mCallback.onUpgrade(getWrappedDb(sqLiteDatabase), oldVersion, newVersion);
+            } catch (Throwable t) {
+                throw new CallbackException(CallbackName.ON_UPGRADE, t);
+            }
         }
 
         @Override
         public void onConfigure(SQLiteDatabase db) {
-            mCallback.onConfigure(getWrappedDb(db));
+            try {
+                mCallback.onConfigure(getWrappedDb(db));
+            } catch (Throwable t) {
+                throw new CallbackException(CallbackName.ON_CONFIGURE, t);
+            }
         }
 
         @Override
         public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
             mMigrated = true;
-            mCallback.onDowngrade(getWrappedDb(db), oldVersion, newVersion);
+            try {
+                mCallback.onDowngrade(getWrappedDb(db), oldVersion, newVersion);
+            } catch (Throwable t) {
+                throw new CallbackException(CallbackName.ON_DOWNGRADE, t);
+            }
         }
 
         @Override
         public void onOpen(SQLiteDatabase db) {
             if (!mMigrated) {
                 // if we've migrated, we'll re-open the db so we should not call the callback.
-                mCallback.onOpen(getWrappedDb(db));
+                try {
+                    mCallback.onOpen(getWrappedDb(db));
+                } catch (Throwable t) {
+                    throw new CallbackException(CallbackName.ON_OPEN, t);
+                }
             }
             mOpened = true;
         }
@@ -241,5 +352,36 @@
             }
             return refHolder[0];
         }
+
+        private static final class CallbackException extends RuntimeException {
+
+            private final CallbackName mCallbackName;
+            private final Throwable mCause;
+
+            CallbackException(CallbackName callbackName, Throwable cause) {
+                super(cause);
+                mCallbackName = callbackName;
+                mCause = cause;
+            }
+
+            public CallbackName getCallbackName() {
+                return mCallbackName;
+            }
+
+            @NonNull
+            @Override
+            @SuppressWarnings("UnsynchronizedOverridesSynchronized") // Not needed, cause is final
+            public Throwable getCause() {
+                return mCause;
+            }
+        }
+
+        enum CallbackName {
+            ON_CONFIGURE,
+            ON_CREATE,
+            ON_UPGRADE,
+            ON_DOWNGRADE,
+            ON_OPEN
+        }
     }
 }
diff --git a/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelperFactory.java b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelperFactory.java
index 2f55202..34a0ce0 100644
--- a/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelperFactory.java
+++ b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/db/framework/FrameworkSQLiteOpenHelperFactory.java
@@ -33,6 +33,7 @@
                 configuration.context,
                 configuration.name,
                 configuration.callback,
-                configuration.useNoBackupDirectory);
+                configuration.useNoBackupDirectory,
+                configuration.allowDataLossOnRecovery);
     }
 }
diff --git a/sqlite/sqlite-framework/src/main/java/androidx/sqlite/util/SneakyThrow.java b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/util/SneakyThrow.java
new file mode 100644
index 0000000..e1309b4
--- /dev/null
+++ b/sqlite/sqlite-framework/src/main/java/androidx/sqlite/util/SneakyThrow.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.sqlite.util;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+
+/**
+ * Java 8 Sneaky Throw technique.
+ *
+ * @hide
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class SneakyThrow {
+
+    /**
+     * Re-throws a throwable as if it was a runtime exception without wrapping it.
+     *
+     * @param t the throwable to re-throw.
+     */
+    public static void reThrow(@NonNull Throwable t) {
+        sneakyThrow(t);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <E extends Throwable> void sneakyThrow(@NonNull Throwable t) throws E {
+        throw (E) t;
+    }
+
+    private SneakyThrow() {
+
+    }
+}
diff --git a/sqlite/sqlite/api/api_lint.ignore b/sqlite/sqlite/api/api_lint.ignore
index 4e9a7e3..3d31715 100644
--- a/sqlite/sqlite/api/api_lint.ignore
+++ b/sqlite/sqlite/api/api_lint.ignore
@@ -41,6 +41,8 @@
     Builder methods names should use setFoo() / addFoo() / clearFoo() style: method androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder.name(String)
 BuilderSetStyle: androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder#noBackupDirectory(boolean):
     Builder methods names should use setFoo() / addFoo() / clearFoo() style: method androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder.noBackupDirectory(boolean)
+BuilderSetStyle: androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder#allowDataLossOnRecovery(boolean):
+    Builder methods names should use setFoo() / addFoo() / clearFoo() style: method androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder.allowDataLossOnRecovery(boolean)
 BuilderSetStyle: androidx.sqlite.db.SupportSQLiteQueryBuilder#builder(String):
     Builder methods names should use setFoo() / addFoo() / clearFoo() style: method androidx.sqlite.db.SupportSQLiteQueryBuilder.builder(String)
 BuilderSetStyle: androidx.sqlite.db.SupportSQLiteQueryBuilder#columns(String[]):
diff --git a/sqlite/sqlite/api/current.txt b/sqlite/sqlite/api/current.txt
index dbdea61..927cb1b 100644
--- a/sqlite/sqlite/api/current.txt
+++ b/sqlite/sqlite/api/current.txt
@@ -74,6 +74,7 @@
 
   public static class SupportSQLiteOpenHelper.Configuration {
     method public static androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder builder(android.content.Context);
+    field public final boolean allowDataLossOnRecovery;
     field public final androidx.sqlite.db.SupportSQLiteOpenHelper.Callback callback;
     field public final android.content.Context context;
     field public final String? name;
@@ -81,6 +82,7 @@
   }
 
   public static class SupportSQLiteOpenHelper.Configuration.Builder {
+    method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder allowDataLossOnRecovery(boolean);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration build();
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder callback(androidx.sqlite.db.SupportSQLiteOpenHelper.Callback);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder name(String?);
diff --git a/sqlite/sqlite/api/public_plus_experimental_current.txt b/sqlite/sqlite/api/public_plus_experimental_current.txt
index dbdea61..927cb1b 100644
--- a/sqlite/sqlite/api/public_plus_experimental_current.txt
+++ b/sqlite/sqlite/api/public_plus_experimental_current.txt
@@ -74,6 +74,7 @@
 
   public static class SupportSQLiteOpenHelper.Configuration {
     method public static androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder builder(android.content.Context);
+    field public final boolean allowDataLossOnRecovery;
     field public final androidx.sqlite.db.SupportSQLiteOpenHelper.Callback callback;
     field public final android.content.Context context;
     field public final String? name;
@@ -81,6 +82,7 @@
   }
 
   public static class SupportSQLiteOpenHelper.Configuration.Builder {
+    method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder allowDataLossOnRecovery(boolean);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration build();
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder callback(androidx.sqlite.db.SupportSQLiteOpenHelper.Callback);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder name(String?);
diff --git a/sqlite/sqlite/api/restricted_current.txt b/sqlite/sqlite/api/restricted_current.txt
index dbdea61..927cb1b 100644
--- a/sqlite/sqlite/api/restricted_current.txt
+++ b/sqlite/sqlite/api/restricted_current.txt
@@ -74,6 +74,7 @@
 
   public static class SupportSQLiteOpenHelper.Configuration {
     method public static androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder builder(android.content.Context);
+    field public final boolean allowDataLossOnRecovery;
     field public final androidx.sqlite.db.SupportSQLiteOpenHelper.Callback callback;
     field public final android.content.Context context;
     field public final String? name;
@@ -81,6 +82,7 @@
   }
 
   public static class SupportSQLiteOpenHelper.Configuration.Builder {
+    method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder allowDataLossOnRecovery(boolean);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration build();
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder callback(androidx.sqlite.db.SupportSQLiteOpenHelper.Callback);
     method public androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration.Builder name(String?);
diff --git a/sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.java b/sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.java
index 0123606..55d37ea 100644
--- a/sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.java
+++ b/sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.java
@@ -322,6 +322,11 @@
          * If {@code true} the database will be stored in the no-backup directory.
          */
         public final boolean useNoBackupDirectory;
+        /**
+         * If {@code true} the database will be delete and its data loss in the case that it
+         * cannot be opened.
+         */
+        public final boolean allowDataLossOnRecovery;
 
         Configuration(
                 @NonNull Context context,
@@ -335,10 +340,20 @@
                 @Nullable String name,
                 @NonNull Callback callback,
                 boolean useNoBackupDirectory) {
+            this(context, name, callback, useNoBackupDirectory, false);
+        }
+
+        Configuration(
+                @NonNull Context context,
+                @Nullable String name,
+                @NonNull Callback callback,
+                boolean useNoBackupDirectory,
+                boolean allowDataLossOnRecovery) {
             this.context = context;
             this.name = name;
             this.callback = callback;
             this.useNoBackupDirectory = useNoBackupDirectory;
+            this.allowDataLossOnRecovery = allowDataLossOnRecovery;
         }
 
         /**
@@ -359,6 +374,7 @@
             String mName;
             SupportSQLiteOpenHelper.Callback mCallback;
             boolean mUseNoBackupDirectory;
+            boolean mAllowDataLossOnRecovery;
 
             /**
              * <p>
@@ -386,7 +402,8 @@
                             "Must set a non-null database name to a configuration that uses the "
                                     + "no backup directory.");
                 }
-                return new Configuration(mContext, mName, mCallback, mUseNoBackupDirectory);
+                return new Configuration(mContext, mName, mCallback, mUseNoBackupDirectory,
+                        mAllowDataLossOnRecovery);
             }
 
             Builder(@NonNull Context context) {
@@ -424,6 +441,19 @@
                 mUseNoBackupDirectory = useNoBackupDirectory;
                 return this;
             }
+
+            /**
+             * Sets whether to delete and recreate the database file in situations when the
+             * database file cannot be opened, thus allowing for its data to be lost.
+             * @param allowDataLossOnRecovery If {@code true} the database file might be recreated
+             *                                in the case that it cannot be opened.
+             * @return this
+             */
+            @NonNull
+            public Builder allowDataLossOnRecovery(boolean allowDataLossOnRecovery) {
+                mAllowDataLossOnRecovery = allowDataLossOnRecovery;
+                return this;
+            }
         }
     }