Cómo leer los datos de la carpeta de activos Archivo de base de datos sqlite con extensión .sqlite en mi aplicación Android?Android: Accediendo a la carpeta de activos Archivo de base de datos sqlite con la extensión .sqlite
Si está planeando crear una nueva base de datos SQLite, entonces use el método onCreate() como se muestra en el tutorial.
Pero si está utilizando una base de datos SQLite creada por otra fuente externa y la va a extraer, deje el método onCreate() vacío.
Es importante que en el tutorial, cuando llame al archivo, asegúrese de pasar el contexto de la aplicación getApplicationContext() para que tenga acceso a los recursos correctos, de lo contrario, podría obtener una excepción FileNotFound.
probar este código:
public class DataBaseHelper extends SQLiteOpenHelper {
private Context mycontext;
//private String DB_PATH = mycontext.getApplicationContext().getPackageName()+"/databases/";
private static String DB_NAME = "(datbasename).sqlite";//the extension may be .sqlite or .db
public SQLiteDatabase myDataBase;
/*private String DB_PATH = "/data/data/"
+ mycontext.getApplicationContext().getPackageName()
+ "/databases/";*/
public DataBaseHelper(Context context) throws IOException {
super(context,DB_NAME,null,1);
this.mycontext=context;
boolean dbexist = checkdatabase();
if (dbexist) {
//System.out.println("Database exists");
opendatabase();
} else {
System.out.println("Database doesn't exist");
createdatabase();
}
}
public void createdatabase() throws IOException {
boolean dbexist = checkdatabase();
if(dbexist) {
//System.out.println(" Database exists.");
} else {
this.getReadableDatabase();
try {
copydatabase();
} catch(IOException e) {
throw new Error("Error copying database");
}
}
}
private boolean checkdatabase() {
//SQLiteDatabase checkdb = null;
boolean checkdb = false;
try {
String myPath = DB_PATH + DB_NAME;
File dbfile = new File(myPath);
//checkdb = SQLiteDatabase.openDatabase(myPath,null,SQLiteDatabase.OPEN_READWRITE);
checkdb = dbfile.exists();
} catch(SQLiteException e) {
System.out.println("Database doesn't exist");
}
return checkdb;
}
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("/data/data/(packagename)/databases /(datbasename).sqlite");
// transfer byte to inputfile to 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);
}
public synchronized void close() {
if(myDataBase != null) {
myDataBase.close();
}
super.close();
}
}
nice, funciona bien para mí; d –
Al codificar esto para la producción, use mycontext.getApplicationInfo(). DataDir en lugar de la codificación dura "/ data/data/(packagename)". Esta es la forma oficial de obtener el directorio de datos de la aplicación. – wheredidthatnamecomefrom
Lugar antigua base de datos (old.db) en su carpeta de recursos. Escribe esto en el interior onCreate() de su actividad:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
....
//=======Code For copying Existing Database file to system folder for use====//
// Copying Existing Database into system folder
try {
String destPath = "/data/data/" + getPackageName()
+ "/databases/data.db";
File f = new File(destPath);
if(!f.exists()){
Log.v(TAG,"File Not Exist");
InputStream in = getAssets().open("old.db");
OutputStream out = new FileOutputStream(destPath);
byte[] buffer = new byte[1024];
int length;
while ((length = in.read(buffer)) > 0) {
out.write(buffer, 0, length);
}
in.close();
out.close();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
Log.v("TAG","ioexeption");
e.printStackTrace();
}
DBManager dbManager = new DBManager(this);
Log.v(TAG,"Database is there with version: "+dbManager.getReadableDatabase().getVersion());
String sql = "select * from prizes";
SQLiteDatabase db = dbManager.getReadableDatabase();
Cursor cursor = db.rawQuery(sql, null);
Log.v(TAG,"Query Result:"+cursor);
cursor.close();
db.close();
dbManager.close();
....
}
Ahora tiene que hacer una clase DBManager cuales subclases SQLiteOpenHelper. Inserta el método abstracto y el constructor. No olvide escribir el nombre correcto de la base de datos dentro de super() de dbHelper.
public class DBManager extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
private static final String TAG = "DATABASES";
public DBManager(Context context) {
super(context, "data.db", null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
Log.v(TAG,"On create Called:"+db.getPath());
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
Ahora puede acceder a la base de datos instanciando DBManager.
SQLiteDatabase db = dbManager.getReadableDatabase();
Cursor cursor = db.rawQuery(sql, null);
...
No olvide cerrar la base de datos o obtendrá una excepción SQLiteDatabaseNotClosed.
db.close();
dbManager.close();
Querrá probar android sqlite asset helper. Hizo que abrir un db preexistente fuera un pedazo de pastel para mí.
Literalmente lo tuve funcionando en aproximadamente media hora después de pasar 3 horas tratando de hacerlo todo manualmente. Lo curioso es que pensé que estaba haciendo lo mismo que la biblioteca hizo por mí, ¡pero faltaba algo!
Solo puede leer la base de datos de la carpeta de activos ya que las carpetas de recursos son de solo lectura. Si necesita hacer más operaciones como crear, actualizar, eliminar, puede hacer algunos trucos. Copia la base de datos de la carpeta de activos al almacenamiento y luego puedes hacer lo que quieras.
Aquí está un ejemplo rápido de Working with Android Pre Built Database.
Hay una biblioteca fácil de utilizar también para acceder a la base de datos de la carpeta activos. Puede verificar Android SQLiteAssetHelper (https://github.com/jgilfelt/android-sqlite-asset-helper). ¡Buena suerte!
Necesita convertir su base de datos .sqlite a .db para adaptarla a Android.
en el primer lanzamiento de la aplicación después de la instalación
SuperDatabase database=new SuperDatabase(getApplicationContext(),"foods.db", AssetDatabaseMode.COPY_TO_SYSTEM);
En lanzamientos posteriores
SuperDatabase database=new SuperDatabase(getApplicationContext(),"foods.db", AssetDatabaseMode.READ_FROM_DEVICE);
Simplemente disparar consultas SQL
database.sqlInject("INSERT INTO food VALUES('Banana','Vitamin A');");
obtener resultados en la matriz en CSV, JSON, XML
ArrayList<String> rows=new ArrayList<String>();
rows=database.sqlEjectCSV("SELECT * FROM food;");
for (int i=0;i<rows.size();i++)
{
//Do stuffs with each row
}
Necesita incluir mi biblioteca para esto. Documentaciones aquí:
https://github.com/sangeethnandakumar/TestTube
¿Por qué colocaste el archivo .sqlite en la carpeta assets en lugar de/res/raw? – Macarse
Querrá probar [android sqlite asset helper] (https://github.com/jgilfelt/android-sqlite-asset-helper). Lo hace un pedazo de pastel. – craned