Android cómo actualizar, pero conservar la información de la base de datos

Question

Tengo una aplicación que utiliza una base de datos SQLite. Cuando la aplicación se actualiza en este momento, sobrescribe completamente la base de datos.

El problema surge cuando quiero transferir el progreso actual de los usuarios a la nueva actualización. La tabla db contiene filas de preguntas. Cada fila contiene 1 pregunta, las respuestas, el motivo de la respuesta correcta, si el usuario la ha respondido y si el usuario respondió correctamente.

En una actualización, una pregunta podría haberse eliminado y/o agregado. La única información que debe conservarse es si se ha respondido una pregunta y se responde correctamente. ¿Existe un método mejor para transferir los datos que no sea la comparación de un número único o cadena de cada fila del antiguo db con el nuevo db?

Con más de 100 filas, esto parece requerir muchos recursos. Aunque no puedo ver otra forma de solucionar este problema.

Cualquier consejo y ayuda se recibirán con gratitud.

Answer 1

Estoy de acuerdo con @Yashwanth Kumar un diseño diferente podría ser mejor a largo plazo, pero 100 filas no es masivo.

Implementa la lógica en DBhelper.onUpgrade().

Es posible que desee ver el almacenamiento de las respuestas en las preferencias compartidas mientras se lleva a cabo la operación de actualización en caso de que el sistema o el usuario lo mate.

Answer 2

Podría sugerir una alternativa en su diseño, mantener 2 tablas, una para responder correctamente y la otra para descansar. cuando una pregunta ha sido respondida correctamente, transfiera la pregunta de una tabla a la tabla de preguntas respondidas.

así que cuando esté actualizando, simplemente suelte la tabla de preguntas sin responder y rellene con las nuevas. las preguntas respondidas están ilesas en el camino.

Answer 3

Primera asignar a cada mesa de un único id - Clave principal (PK)

tabla de preguntas - muchos a uno la relación con el Usuario
mesa respuesta - relación uno a uno con la pregunta
tabla de usuario - uno a muchos con la pregunta

 
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 

Cuando la aplicación se descarga, el usuario puede registrarse de forma silenciosa, utilizando el UUID del dispositivo. La base de datos central tendrá que hacer un seguimiento de estas y las preguntas que se responden, en lugar de borrar todo y comenzar de nuevo. 100 filas no son muchas, pero los usuarios podrían potencialmente alcanzar los 1000 o más. En una actualización no es relevante que sea lento repoblar la base de datos local en el teléfono (aunque no necesariamente sería lenta con estas filas, una base de datos con millones de filas llevaría tiempo) ya que se espera que las actualizaciones tomen hora.

Si el usuario cambia de dispositivo, esta información no se transfiere al nuevo dispositivo. Cada dispositivo se trata como un nuevo usuario. Me parece que esto funciona bien si no quieres que las personas se registren, pero desean conservar los datos durante las actualizaciones, o si la aplicación se desinstala y vuelve a instalar en un dispositivo. Tiene sus limitaciones al igual que pedirle a la gente que se registre. Si los usuarios quieren un nuevo comienzo en el juego con el mismo dispositivo, siempre pueden proporcionar una opción "Restablecer estadísticas" y luego borrar esos datos.

Las preferencias compartidas también se pueden usar para guardar la configuración del usuario para la aplicación, creo que puede ser exagerado para un centenar de preguntas, sería mejor almacenar esta información en una base de datos SQLite; la información se mantiene en el servidor. No puede borrar los datos cada vez que hay una actualización, debe mantener registros actuales del progreso del consumidor. No puede confiar en que el dispositivo del consumidor retenga la información. Si hay alguna información que desea realizar un seguimiento, debe asumir la responsabilidad para ello.

Esto se puede almacenar localmente en el teléfono y sincronizar con el servidor regularmente.

En nuestras aplicaciones, así es como lo hacemos y los datos sobreviven a las actualizaciones y tenemos millones de filas. No dude en hacer más preguntas, sin embargo, dar un tutorial real (o el código) de cómo funciona todo esto es una respuesta un poco amplia para Stack Overflow.