Vincoli di chiave esterna in Android utilizzando SQLite? su Elimina cascata

Ho due tabelle: tracce e waypoint, una traccia può avere molti waypoint, ma un waypoint è assegnato solo a 1 traccia.

Nella tabella way points ho una colonna chiamata "trackidfk" che inserisce il track_ID una volta creata una traccia, tuttavia non ho impostato i vincoli di Foreign Key su questa colonna.

Quando elimino una traccia, desidero eliminare i waypoint assegnati, è possibile ?. Ho letto sull'utilizzo dei trigger ma non credo che siano supportati in Android.

Per creare la tabella dei waypoint:

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"
                + " );"
              );

    ...
}

I vincoli di chiave esterna con cascata all'eliminazione sono supportati, ma è necessario abilitarli.
Ho appena aggiunto quanto segue al mio SQLOpenHelper , che sembra fare il trucco.

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

Ho dichiarato la mia colonna di riferimento come segue.

mailbox_id INTEGER REFERENCES mailboxes ON DELETE CASCADE

A partire da Android 4.1 (API 16) SQLiteDatabase supporta:

public void setForeignKeyConstraintsEnabled (boolean enable)

Come dice il post di e.shishkin dall'API 16 in su, dovresti abilitare i vincoli di chiave esterna nel SqLiteOpenHelper.onConfigure(SqLiteDatabase)metodo usando ildb.setForeignKeyConstraintsEnabled(boolean)

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

Mai una domanda troppo vecchia per rispondere con una risposta più 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);
}

Qualunque cosa abbia menzionato @phil è buona. Ma puoi usare un altro metodo predefinito disponibile nel database stesso per impostare la chiave esterna. Questo è setForeignKeyConstraintsEnabled (true).

@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)
    }
}

Per i documenti fare riferimento a SQLiteDatabase.setForeignKeyConstraintsEnabled

Non penso che SQLite lo supporti fuori dagli schemi. Quello che sto facendo nelle mie app è:

1. Crea transazione
2. Elimina i dati di dettaglio (waypoint nel tuo esempio)
3. Elimina i dati principali (tracce nel tuo esempio)
4. Impegnare la transazione in caso di successo

In questo modo sono sicuro che tutti i dati vengono eliminati o nessuno.

I trigger sono supportati da Android e quel tipo di eliminazione a cascata non è supportato da sqlite. Un esempio di utilizzo dei trigger su Android può essere trovato qui . Anche se usare le transazioni come ha affermato Thorsten è probabilmente facile come un trigger.

La versione di SQLite in Android 1.6 è 3.5.9 quindi non supporta chiavi esterne ...

http://www.sqlite.org/foreignkeys.html "Questo documento descrive il supporto per i vincoli di chiave esterna SQL introdotti nella versione 3.6.19 di SQLite."

In Froyo è la versione SQLite 3.6.22, quindi ...

EDIT: per vedere la versione sqlite: adb shell sqlite3 -version

Le chiavi esterne con "all'eliminazione a cascata" sono supportate in SQLite in Android 2.2 e versioni successive. Ma fai attenzione quando li usi: a volte viene segnalato un errore quando si attiva una chiave esterna su una colonna, ma il vero problema risiede nel vincolo di chiave esterna di un'altra colonna nella tabella figlia o in qualche altra tabella che fa riferimento a questa tabella.

Sembra che SQLite controlli tutti i vincoli quando ne attiva uno. In realtà è menzionato nella documentazione. Controlli dei vincoli DDL e DML.

Se stai usando Android Room, fai come mostrato di seguito.

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()