Estoy usando este DataBaseHelper.class y estoy atascado en el método onUpgrade(). No sé cómo averiguar cuál es el número de versión de la base de datos. Podría establecer la versión en 1, la primera vez que la publique y cuando publique una actualización, simplemente podría establecer la versión en 2 (myDataBase.setVersion(2);). Pero solo será 2 siempre que la aplicación se esté ejecutando. La próxima vez que se inicie, es 1 de nuevo. Lo mismo ocurre con private static int DATABASE_VERSION. Estaba pensando en almacenar el número de versión en una mesa extra, pero esta no parece ser la mejor práctica en mi opinión.onUpgrade database - oldVersion - newVersion
Entonces, ¿cómo se asegura de que el número de versión haya aumentado después de una actualización y que lo mantiene (el valor que fue asignado a private static int DATABASE_VERSION o myDataBase.getVersion();)?
El DataBaseHelper clase:
public class DataBaseHelper extends SQLiteOpenHelper {
//The Android's default system path of your application database.
private static String DB_PATH = "/data/data/com.mydatabase.db/databases/";
private static String DB_NAME = "database.sl3";
private SQLiteDatabase myDataBase;
private final Context myContext;
// Do you need this?
private static int DATABASE_VERSION = 2;
// or is this correct:
// private static int DATABASE_VERSION = myDataBase.getVersion();
/**
* Constructor
* Takes and keeps a reference of the passed context in order to access to
* the application assets and resources.
*
* @param context
*/
public DataBaseHelper(Context context) {
super(context, DB_NAME, null, DATABASE_VERSION);
this.myContext = context;
}
/**
* Creates an empty database on the system and rewrites it with your own
* database.
* */
public void
createDataBase() throws IOException {
boolean dbExist = checkDataBase();
if (dbExist) {
}
else {
//By calling this method and empty database will be created into the default system path
//of your application so we are gonna be able to overwrite that database with our database.
this.getWritableDatabase();
try {
copyDataBase();
} catch (IOException e) {
throw new Error("Error copying database");
}
}
}
/**
* Check if the database already exist to avoid re-copying the file each
* time you open the application.
*
* @return true if it exists, false if it doesn't
*/
private boolean
checkDataBase() {
SQLiteDatabase checkDB = null;
try {
String myPath = DB_PATH + DB_NAME;
checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
} catch (SQLiteException e) {
//database does't exist yet.
}
if (checkDB != null) {
checkDB.close();
}
return checkDB != null ? true : false;
}
/**
* Copies your database from your local assets-folder to the just created
* empty database in the
* system folder, from where it can be accessed and handled.
* This is done by transfering bytestream.
* */
private void
copyDataBase() throws IOException {
//Open your local db as the input stream
InputStream myInput = myContext.getAssets().open(DB_NAME);
// Path to the just created empty db
String outFileName = DB_PATH + DB_NAME;
//Open the empty db as the output stream
OutputStream myOutput = new FileOutputStream(outFileName);
//transfer bytes from the inputfile to the outputfile
byte[] buffer = new byte[1024];
int length;
while ((length = myInput.read(buffer)) > 0) {
myOutput.write(buffer, 0, length);
}
//Close the streams
myOutput.flush();
myOutput.close();
myInput.close();
}
public void
openDataBase() throws SQLException {
//Open the database
String myPath = DB_PATH + DB_NAME;
myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
// Which parameters do I have to pass?
onUpgrade(myDataBase, DATABASE_VERSION, 2);
}
@Override
public synchronized void
close() {
if (myDataBase != null)
myDataBase.close();
super.close();
}
@Override
public void
onCreate(SQLiteDatabase db) {
}
@Override
public void
onUpgrade( SQLiteDatabase db,
int oldVersion,
int newVersion) {
Log.d ("onUpgrade first log", Integer.toString(myDataBase.getVersion()));
if (oldVersion == 1) {
// do something
// And then do this!?
DATABASE_VERSION = 2;
// or do this
myDataBase.setVersion(2);
Log.d ("onUpgrade sedond log", Integer.toString(myDataBase.getVersion()));
}
else {
Log.d("onUpgrade", "else-clause: Already upgraded!");
}
}
Hola Graham Borland! Tiene razón, importo una base de datos existente de la carpeta de activos y creo que esto es lo que necesito _aplicarlo directamente al archivo de base de datos en sus assets_! ¿Pero cómo hago esto? – BenjaminButton
Con _it_ quise decir el número de versión. – BenjaminButton
¡Lo tengo funcionando! En la clase createDataBase faltaba una línea: 'public void createDataBase() arroja IOException {boolean dbExist = checkDataBase(); if (dbExist) {/ * Esta línea: */this.getWritableDatabase();} ... ' Además se invoca onUpgrade() cuando se crea un nuevo objeto de la clase DataBaseHelper ** pero ** solo si la base de datos los números de versión no coinciden. Por lo tanto, esto significa que no es necesario llamar a Actualizaciones "por su cuenta". Si publica una actualización de su base de datos, simplemente incremente la versión nr en uno y aplique los cambios en el método onUpgrade(). Espero que ayude a cualquiera! – BenjaminButton