¿Restricciones de clave externa en Android usando SQLite? en Eliminar cascada

Tengo dos tablas: tracks y waypoints, un track puede tener muchos waypoints, pero un waypoint se asigna a solo 1 track.

En la tabla de puntos de ruta, tengo una columna llamada "trackidfk" que inserta el track_ID una vez que se crea una pista, sin embargo, no he configurado las restricciones de clave externa en esta columna.

Cuando borro un track quiero borrar los waypoints asignados, ¿es posible ?. Leí sobre el uso de Triggers, pero no creo que sean compatibles con Android.

Para crear la tabla de waypoints:

public void onCreate(SQLiteDatabase db) {
    db.execSQL( "CREATE TABLE " + TABLE_NAME 
                + " (" 
                + _ID         + " INTEGER PRIMARY KEY AUTOINCREMENT, " 
                + LONGITUDE   + " INTEGER," 
                + LATITUDE    + " INTEGER," 
                + TIME        + " INTEGER,"
                + TRACK_ID_FK + " INTEGER"
                + " );"
              );

    ...
}

Se admiten las restricciones de clave externa con cascada de eliminación, pero debe habilitarlas.
Acabo de agregar lo siguiente a mi SQLOpenHelper , que parece funcionar.

@Override
public void onOpen(SQLiteDatabase db) {
    super.onOpen(db);
    if (!db.isReadOnly()) {
        // Enable foreign key constraints
        db.execSQL("PRAGMA foreign_keys=ON;");
    }
}

Declaré mi columna de referencia de la siguiente manera.

mailbox_id INTEGER REFERENCES mailboxes ON DELETE CASCADE

Desde Android 4.1 (API 16), SQLiteDatabase admite:

public void setForeignKeyConstraintsEnabled (boolean enable)

Como dice la publicación de e.shishkin de API 16 en adelante, debe habilitar las restricciones de clave externa en el SqLiteOpenHelper.onConfigure(SqLiteDatabase)método utilizando eldb.setForeignKeyConstraintsEnabled(boolean)

@Override
public void onConfigure(SQLiteDatabase db){
    db.setForeignKeyConstraintsEnabled(true);
}

Nunca una pregunta demasiado vieja para responder con una respuesta más completa.

@Override public void onOpen(SQLiteDatabase db) {
    super.onOpen(db);
    if (!db.isReadOnly()) {
        setForeignKeyConstraintsEnabled(db);
    }
    mOpenHelperCallbacks.onOpen(mContext, db);
}

private void setForeignKeyConstraintsEnabled(SQLiteDatabase db) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
        setForeignKeyConstraintsEnabledPreJellyBean(db);
    } else {
        setForeignKeyConstraintsEnabledPostJellyBean(db);
    }
}

private void setForeignKeyConstraintsEnabledPreJellyBean(SQLiteDatabase db) {
    db.execSQL("PRAGMA foreign_keys=ON;");
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
private void setForeignKeyConstraintsEnabledPostJellyBean(SQLiteDatabase db) {
    db.setForeignKeyConstraintsEnabled(true);
}

Lo que sea que @phil mencione es bueno. Pero puede usar otro método predeterminado disponible en la base de datos para configurar la clave externa. Eso es setForeignKeyConstraintsEnabled (verdadero).

@Override
public void onOpen(SQLiteDatabase db) {
    super.onOpen(db);
    if (!db.isReadOnly()) {
        // Enable foreign key constraints
        db.execSQL("PRAGMA foreign_keys=ON;"); 
              //(OR)
        db.setForeignKeyConstraintsEnabled (true)
    }
}

Para documentos, consulte SQLiteDatabase.setForeignKeyConstraintsEnabled

No creo que SQLite admita esto de inmediato. Lo que estoy haciendo en mis aplicaciones es:

1. Crear transacción
2. Eliminar datos detallados (waypoints en su ejemplo)
3. Eliminar datos maestros (pistas en su ejemplo)
4. Comprometer la transacción en caso de éxito

De esa manera, estoy seguro de que se eliminan todos los datos o ninguno.

Los activadores son compatibles con Android y ese tipo de eliminación en cascada no es compatible con sqlite. Aquí puede encontrar un ejemplo del uso de activadores en Android . Aunque usar transacciones como dijo Thorsten es probablemente tan fácil como un disparador.

La versión de SQLite en Android 1.6 es 3.5.9, por lo que no admite claves externas ...

http://www.sqlite.org/foreignkeys.html "Este documento describe la compatibilidad con las restricciones de clave externa de SQL introducidas en la versión 3.6.19 de SQLite".

En Froyo es SQLite versión 3.6.22, así que ...

EDITAR: para ver la versión de sqlite: adb shell sqlite3 -version

Las claves externas con "en cascada de eliminación" son compatibles con SQLite en Android 2.2 y versiones posteriores. Pero tenga cuidado al usarlos: a veces se informa un error al activar una clave externa en una columna, pero el problema real radica en otra restricción de clave externa de columna en la tabla secundaria, o en alguna otra tabla que hace referencia a esta tabla.

Parece que SQLite comprueba todas las restricciones al activar una de ellas. De hecho, se menciona en la documentación. Verificaciones de restricciones DDL versus DML.

Si está utilizando Android Room, haga lo que se muestra a continuación.

Room.databaseBuilder(context, AppDatabase::class.java, DATABASE_NAME)
    .addCallback(object : RoomDatabase.Callback() {
        // Called when the database has been opened.
        override fun onOpen(db: SupportSQLiteDatabase) {
            super.onOpen(db)
            //True to enable foreign key constraints
            db.setForeignKeyConstraintsEnabled(true)
        }

        // Called when the database is created for the first time. 
        override fun onCreate(db: SupportSQLiteDatabase) {
            super.onCreate(db)
        }
    }).build()