Android come aggiornare, ma conservare le informazioni del database

Question

Ho un'app che utilizza un database SQLite. Quando l'app si aggiorna al momento, sovrascrive completamente il database.

Il problema si presenta quando voglio trasferire gli utenti sul progresso corrente al nuovo aggiornamento. La tabella db contiene righe di domande. Ogni riga contiene 1 domanda, le risposte, il motivo della risposta corretta, se l'utente ha risposto e se l'utente ha risposto correttamente.

In un aggiornamento una domanda avrebbe potuto essere cancellata e/o altre aggiunte. Gli unici dati che devono essere conservati sono se una domanda ha avuto risposta e se è stata data una risposta corretta. Esiste un metodo migliore per trasferire i dati oltre che confrontare un numero o una stringa univoci da ciascuna riga del vecchio db al nuovo db?

Con oltre 100 righe, sembra che richieda molte risorse. Anche se non riesco a vedere un altro modo per aggirare questo problema.

Qualsiasi consiglio e aiuto sarebbe stato accolto con gratitudine.

Answer 1

Sono d'accordo con @Yashwanth Kumar un design diverso potrebbe essere migliore a lungo termine, ma 100 righe non sono enormi.

Logica di implementazione in DBhelper.onUpgrade().

Si potrebbe desiderare di archiviare le risposte nelle preferenze condivise mentre l'operazione di aggiornamento si sta verificando, in quanto viene chiusa dal sistema/utente.

Answer 2

Posso suggerire un'alternativa nella progettazione, mantenere 2 tabelle, una per la risposta corretta e l'altra per il riposo. quando una domanda ha ricevuto una risposta corretta, trasferisci la domanda da una tabella alla tabella delle domande con risposta.

così quando si sta aggiornando, basta rilasciare la tabella delle domande senza risposta e popolarla con quelle nuove. le domande con risposta sono incolumi nel modo.

Answer 3

Prima allocare ogni tavolo un ID univoco - chiave primaria (PK)

tavolo Domanda - molti a uno rapporto con l'utente
tavolo risposta - relazione uno a uno con una domanda
tabella utente - uno a molti con domanda

 
Question 
+--------------+------------+------------------+ 
| int   | Id   | PK    | 
| varchar(max) | question |     | 
| int   | userId  | FK (Foreign Key) | 
| bool   | answered |     | 
| bool   | correct |     | 
+--------------+------------+------------------+ 

Answer 
+--------------+------------+----+ 
| int   | Id   | PK | 
| int   | questionId | FK | 
| varchar(max) | reason  | | 
+--------------+------------+----+ 

User 
+---------------+-------------+--------------------------------------------+ 
| int   | Id   | PK           | 
| varchar (250) | deviceToken | (UUiD) // some unique identifier per phone | 
+---------------+-------------+--------------------------------------------+ 
// other relevant stuff 

Quando l'applicazione viene scaricata l'utente può essere in silenzio registrati, utilizzando l'UUID dispositivo. Il database centrale dovrà tenere traccia di questi e delle domande a cui viene data risposta, piuttosto che cancellare tutto e ricominciare. 100 righe non sono molte ma gli utenti potrebbero potenzialmente imbattersi nei 1000 o più. In un aggiornamento non è rilevante il fatto che potrebbe essere lento ripopolare il database locale nel telefono (anche se non sarebbe necessariamente lento con questo numero di righe, un database con milioni di righe richiederebbe del tempo) poiché ci si aspetta che gli aggiornamenti prendano tempo.

Se l'utente cambia dispositivo questa informazione non viene trasferita al nuovo dispositivo. Ogni dispositivo viene considerato come un nuovo utente. Trovo che questo funzioni bene se non si desidera che le persone si registrino ma desiderano conservare i dati durante gli aggiornamenti o se l'app viene disinstallata e reinstallata su un unico dispositivo. Ha i suoi limiti come chiedere alle persone di iscriversi. Se gli utenti desiderano un nuovo inizio di gioco con lo stesso dispositivo, puoi sempre fornire un'opzione "Ripristina statistiche" e cancellare i dati.

Le preferenze condivise possono anche essere utilizzate per salvare le impostazioni utente per l'app, penso che potrebbe essere eccessivo per un centinaio di domande, sarebbe meglio essere adatto per memorizzare queste informazioni in un database SQLite; le informazioni vengono mantenute sul server. Non è possibile cancellare i dati ogni volta che c'è un aggiornamento, è necessario mantenere i record correnti dei progressi del consumatore. Non è possibile fare affidamento sul dispositivo del consumatore per conservare le informazioni. Se ci sono informazioni che desideri tenere traccia di, devi assumerti la responsabilità di.

Questo può essere memorizzato localmente sul telefono e sincronizzato con il server regolarmente.

Nelle nostre app, questo è il modo in cui lo facciamo e i dati sopravvivono agli aggiornamenti e abbiamo milioni di righe. Sentiti libero di fare altre domande, tuttavia dare un vero tutorial (o il codice) per come tutto questo funziona è una risposta un po 'ampia per Stack Overflow.