Come leggere i dati dal file di database sqlite della cartella delle risorse con estensione .sqlite nella mia applicazione Android?Android: accesso alla cartella delle risorse file di database sqlite con estensione .sqlite
Se si sta pianificando di creare un nuovo database SQLite, passare oltre e implementare il metodo onCreate() come mostrato nel tutorial.
Ma se si sta utilizzando un database SQLite creato da un'altra fonte esterna e si sta per estrarlo, lasciare vuoto il metodo onCreate().
È importante che nel tutorial, quando si chiama il file, assicurarsi di passare il contesto dell'applicazione getApplicationContext() in modo tale da poter accedere alle risorse corrette, altrimenti si potrebbe ottenere un'eccezione FileNotFound.
provare questo codice:
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, funziona bene per me; d –
In realtà la codifica per la produzione utilizza mycontext.getApplicationInfo(). DataDir piuttosto che hard coding "/ data/data/(nome pacchetto)". Questo è il modo ufficiale per ottenere la directory dei dati dell'applicazione. – wheredidthatnamecomefrom
Luogo di database vecchio (old.db) nella cartella di asset. Digitare questo all'interno onCreate() della vostra attività:
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();
....
}
Ora si devono fare una classe DBManager che sottoclassi SQLiteOpenHelper. Inserisci il metodo astratto e il costruttore. Non dimenticare di digitare il nome corretto del database all'interno di super() di 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) {
}
}
Ora è possibile accedere al database istanziando DBManager.
SQLiteDatabase db = dbManager.getReadableDatabase();
Cursor cursor = db.rawQuery(sql, null);
...
Non dimenticare di chiudere il database o si otterrà un'eccezione SQLiteDatabaseNotClosed.
db.close();
dbManager.close();
Volete provare android sqlite asset helper. Ha reso l'apertura di un db preesistente un pezzo di torta per me.
Ho letteralmente lavorato in circa mezz'ora dopo aver trascorso 3 ore cercando di eseguire tutto manualmente. La cosa divertente è che pensavo di fare la stessa cosa che la biblioteca ha fatto per me, ma mancava qualcosa!
È possibile leggere solo il database dalla cartella delle risorse poiché le cartelle delle risorse sono di sola lettura. Se devi fare più operazioni come creare, aggiornare, eliminare puoi fare un trucco. Copia il database dalla cartella delle risorse alla memoria e poi puoi fare tutto ciò che vuoi.
Ecco un breve esempio di Working with Android Pre Built Database.
C'è un facile da usare biblioteca troppo per l'accesso ai database dalla cartella Assets. Puoi controllare Android SQLiteAssetHelper (https://github.com/jgilfelt/android-sqlite-asset-helper). In bocca al lupo!
È necessario convertire il database .sqlite in .db inorder per adattarlo ad Android.
Sul primo lancio della tua app dopo l'installazione
SuperDatabase database=new SuperDatabase(getApplicationContext(),"foods.db", AssetDatabaseMode.COPY_TO_SYSTEM);
agli avvii successivi
SuperDatabase database=new SuperDatabase(getApplicationContext(),"foods.db", AssetDatabaseMode.READ_FROM_DEVICE);
Basta sparare query SQL
database.sqlInject("INSERT INTO food VALUES('Banana','Vitamin A');");
ottenere risultati su array in formato 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
}
È necessario includere la mia libreria per questo. Documentazioni qui:
https://github.com/sangeethnandakumar/TestTube
Perché hai inserito il file .sqlite nella cartella delle risorse anziché/res/raw? – Macarse
Dovrai provare [android sqlite asset helper] (https://github.com/jgilfelt/android-sqlite-asset-helper). Lo rende un pezzo di torta. – craned