How to View Your Android App Database: SQLite Database Broswer

I've been using SQLite Database Browser to look through my android database and make changes. Linky link:

http://sourceforge.net/projects/sqlitebrowser/

You can pull your application's database off the emulator as a .sql file and open it up in this browser to see all that fancy sql stuff. 

To get your database off the emulator:

First, you have to have eclipse open and running, and run your application in your emulator of choice. 

Once the app is up and running, go back to eclipse and select Window > Open Perspective > DDMS

Under the Devices tab: Make sure the emulator that is running your app is highlighted/selected. Navigate to the "File Explorer" tab. (If it's not available, select Window > Show View > File Explorer.)

In the File Explorer tab: (1) open the "data" folder, (2) open a second "data" folder, (3) find and open the folder with "your application's name", (4) find and open the "databases" folder, (5) select the file with your application's name

In the upper right of the File Explorer frame, there is a button with an image of a floppy disk with an arrow. Click on the one that says "Pull a file from device" and save your database file somewhere memorable. It might automatically save it to your project's location on your hard drive. 

Now you can view it and play around with it in SQLite Database Browser :)

Keep in mind that you have to upload the new database onto the phone or emulator before the changes can be accessed by your app.

Getting Your Big Ass Database onto Your Android Phone

Yeah, I effing did it!!!!!!!!!! (Sorry, still pumped from finally getting this to work.)

First off: giving credit where credit is due. Many many many thanks to my sources:

http://www.reigndesign.com/blog/using-your-own-sqlite-database-in-android-applications/

http://www.mail-archive.com/android-developers@googlegroups.com/msg28194.html

http://www.chriskopec.com/blog/2010/mar/13/deploying-android-apps-with-large-databases/


My project requires a preformed database (SQLite), which in total comes out to a whopping 17mb. Ridiculous I know, but my boss wants it all packaged with the app, and not just to be available online. Hypothetically, getting this to work should be as easy as creating a blank db and then copying the existing one over it from assets or raw. And this totally works-- if your db is smaller than 1mb. So I went and got some free file splitting software (http://www.dekabyte.com/filesplitter/) and split my db file into 1mb pieces. I put the pieces in the raw directory.

I created the DataBaseHelper class and made the necessary tweaks:


public class DataBaseHelper extends SQLiteOpenHelper {


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


private static final String DB_NAME = "MDAtHand";


private SQLiteDatabase myDataBase;


private final Context myContext;
Resources resources;


/**
* 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;


// super(context, DB_NAME, null, 1);
resources = context.getResources();
}


/**
* 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


copyDataBase();


} 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();


InputStream databaseInput = null;
// String outFileName = DB_PATH + DbConsts.DATABASE_NAME;
String outFileName = DB_PATH + DB_NAME;
OutputStream databaseOutput = new FileOutputStream(outFileName);


byte[] buffer = new byte[1024];
int length;


databaseInput = resources.openRawResource(R.raw.datafile01);
while ((length = databaseInput.read(buffer)) > 0) {
databaseOutput.write(buffer, 0, length);
databaseOutput.flush();
}
databaseInput.close();
databaseInput = resources.openRawResource(R.raw.datafile02);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile03);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();


   databaseInput = resources.openRawResource(R.raw.datafile04);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile05);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile06);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile07);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile08);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile09);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile10);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile11);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile12);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile13);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile14);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile15);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile16);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
   databaseInput = resources.openRawResource(R.raw.datafile17);
   while((length = databaseInput.read(buffer)) > 0) {
       databaseOutput.write(buffer, 0, length);
       databaseOutput.flush();
   }
   databaseInput.close();
databaseOutput.flush();
databaseOutput.close();


}


public void openDataBase() throws SQLException {


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


}


@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.


}

Then I added this awesomeness to the main.java file


DataBaseHelper myDbHelper = new DataBaseHelper(this);
        //myDbHelper = new DataBaseHelper(this);

        try {

         myDbHelper.createDataBase();

  } catch (IOException ioe) {

  throw new Error("Unable to create database");

  }

  try {

  myDbHelper.openDataBase();

  }catch(SQLException sqle){

  throw sqle;

  }


Thats it :)