access .sqlite database in the assets folder

Question

I know it's been asked many times on stackoverflow. Those posts have answers too, but none of them works for me.

I have a database file mydb.sqlite placed it in assets folder. But it fails on the .openDatabase line. What am I doing wrong? In other posts I see that the dbpath pointing to /data/data, but I'm having hard time finding that path in my project.

This is my very first android app. I have been an iphone developer for few years now.

Error: android.database.sqlite.SQLiteCantOpenDatabaseException: unknown error (code 14): Could not open database

    try {
        SQLiteDatabase db = SQLiteDatabase.openDatabase("/android_asset/mydb.sqlite", null, SQLiteDatabase.NO_LOCALIZED_COLLATORS|SQLiteDatabase.OPEN_READONLY);
        Cursor cursor = db.rawQuery("SELECT * FROM mytable", null);
        cursor.moveToFirst();
    } catch (Exception e) {
        e.printStackTrace();
    }

Answer 1

You can only read database from asset folder. If you need to do more operation like create, update, delete you can do a tricks. Copy the database from assets folder to storage and then you can do anything you want.

Here is a quick example of Working with Android Pre Built Database.

There is a easy to use library too for accessing database from assets folder. You can check [Android SQLiteAssetHelper] here.2

Answer 2

The issue was, I was not calling the createDatabase(). This createDatabase() method was in the DatabaseHelper class which I downloaded from somewhere, I'm not sure where from. I put the code here.

ItemListFragment.java: (this is the class I am reading the database from)

DataBaseHelper dataBaseHelper = new DataBaseHelper(getActivity());
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

    DataBaseHelper dataBaseHelper = new DataBaseHelper(getActivity());
        try {
            dataBaseHelper.createDataBase();
            SQLiteDatabase db = dataBaseHelper.openDataBase();
            Cursor cursor = db.rawQuery("SELECT * FROM mydb", null);
            cursor.moveToFirst();
            do {
                String data = cursor.getString(cursor.getColumnIndex("name"));
            }while (cursor.moveToNext());
        } catch (Exception e) {
            e.printStackTrace();
    }
}

DatabaseHelper.java:

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteFullException;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.SQLException;

public class DataBaseHelper extends SQLiteOpenHelper{

    //The Android's default system path of your application database.
    private static String DB_PATH = "/data/data/com.example.myapp.myapplication/databases/";

    private static String DB_NAME = "mydb.sqlite";

    private SQLiteDatabase myDataBase;

    private final Context myContext;
    /**
     * 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, 1);
        this.myContext = context;
    }

    /**
     * Creates a empty database on the system and rewrites it with your own database.
     * */
    public void createDataBase() throws IOException {

        boolean dbExist = checkDataBase();

        if(dbExist){
            //do nothing - database already exist
        }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.getReadableDatabase();

            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_READONLY);

        }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 SQLiteDatabase openDataBase() throws SQLException{

        //Open the database
        String myPath = DB_PATH + DB_NAME;
        myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
        return myDataBase;
    }

    @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) {

    }

    // Add your public helper methods to access and get content from the database.
    // You could return cursors by doing "return myDataBase.query(....)" so it'd be easy
    // to you to create adapters for your views.

}

Answer 3

Those posts have answers too, but none of them works for me.

In the future, explain what you tried and what specific problems you encountered.

In other posts I see that the dbpath pointing to /data/data, but I'm having hard time finding that path in my project

That is because there is no path. Assets are not files on the filesystem on the Android device. They are entries in the ZIP file that is the APK, and they cannot be directly used by SQLite. Instead, they need to be unpacked into a local file first.

The simplest way to use a SQLite database packaged as an asset is to use Jeff Gilfelt's SQLiteAssetHelper.