Develop Reference

How to make changes to the database without having to uninstall APK every time?

public class ProjectConstants {
public static final String myDbName = "ContactsDatabase.db";
public static final String myTableName = "ContactDetails";
// public static final String myTableName = "ContactDetails1";
public static final String nameColumn = "ContactName";
public static final String numberColumn = "ContactNumber";
}
First I create a contact application with Table Name : ContactDetails
Then I do all the adding, editing and deleting operations over that database table. Say I have 15 contact details in that database table named ContactDetails.
Now in the above code snippet I make 2 changes:
I comment this line
//public static final String myTableName = "ContactDetails";
And I uncomment this line
public static final String myTableName = "ContactDetails1";
Now if I run the code, the App crashes.
My learning from Stack Overflow has crudely taught me 2 things to ponder
1.
Remember to uninstall and then reinstall your app so the onCreate
method is called again and the database recreated.
2.
If the database is created for the first time, the onCreate method is
called in the helper class, otherwise onUpgrade is called.
My subclass that extends SQLiteOpenHelper class looks like this,
public class DBHelper extends SQLiteOpenHelper {
private static final String TEXT_TYPE = " TEXT";
private static final String COMMA_SEP = ",";
private static final String SQLCreateEntries =
"CREATE TABLE " + ProjectConstants.myTableName + " (" +
ProjectConstants.nameColumn + TEXT_TYPE + COMMA_SEP +
ProjectConstants.numberColumn + TEXT_TYPE + " )";
private static final String SQLDeleteEntries = "DROP TABLE IF EXISTS " + ProjectConstants.myTableName;
public DBHelper(Context context) {
super(context, String.valueOf(name), null, version);
}
#Override
public void onCreate(SQLiteDatabase sqLiteDatabase) {
sqLiteDatabase.execSQL(SQLCreateEntries);
}
#Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {
sqLiteDatabase.execSQL(SQLDeleteEntries);
onCreate(sqLiteDatabase);
}
Now if I follow the instruction in the 1st quote block by uninstalling and reinstalling the application every time I mess with the database, the app never crashes.
But if I revert back to the original database,(then I do this uninstalling and reinstalling the application) obviously my data in the database do not exist anymore.
As mentioned above my Database table named "ContactDetails" which held 15 contacts will no more have that data now.
But I want that 15 contacts to stay intact inside my database Table "ContactDetails".
Is there anyway to make changes to the database without having to uninstalling-reinstalling apk and without losing the previous data ?

You have write SQL Commands and execute block of SQL commands with different version of code on OnUpgrade() of Helper class as follows:
#Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {
sqLiteDatabase.execSQL(SQLDeleteEntries);
onCreate(sqLiteDatabase);
switch(i){
case 1:
<commands for version 1>
break;
case 2:
<commands for version 2>
break;
}
You can write the swich cases as per version of applications. you can write different block of SQL commands as you want to execute on different version of applications.

In an Android app, where do new SQLite records get saved to in the filesystem?

I am trying to implement an Android application that uses SQLite as its data store. I am using ActiveAndroid. I have a model called Item, and I create items in the following way, calling this from the Activity's onCreate method:
Item item = new Item();
item.name = "test item";
item.save();
After launching my app, I then go to the Android Device Monitor to have access to the database files. And what I see are 2 databases in the filesystem of my app: Application.db and todoListDatabase:
Both of these databases contain a table called items, but only Application.db's version of the items table actually contains the new item records I created. Is that correct?
If this is correct, then what is the point of todoListDatabase?
Edit
Here are the relevant files I have:
My SQLite Helper class:
public class ItemDatabaseHelper extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 2;
private static final String DATABASE_NAME = "todoListDatabase";
private static final String ITEMS = "items";
private static final String KEY_ID = "id";
private static final String KEY_BODY = "name";
public ItemDatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
String CREATE_TODO_TABLE = "CREATE TABLE " + ITEMS + "("
+ KEY_ID + " INTEGER PRIMARY KEY," + KEY_BODY + " TEXT" + ")";
db.execSQL(CREATE_TODO_TABLE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
if (newVersion == 2) {
db.execSQL("DROP TABLE IF EXISTS " + ITEMS);
onCreate(db);
}
}
}
My Item class:
#Table (name = "Items")
public class Item extends Model {
#Column(name = "name")
public String name;
public Item() {
super();
}
public Item(String name){
super();
this.name = name;
}
}

There's just not enough information in this question, to allow it to be answered. SQLite Databases don't just appear. You have to create them. Typically, you do that with a SQLiteOpenHelper.
Unless you do something odd, your database will be in the directory:
/data/data/<your application's package name>/databases
For example, a database for the Google mail application might be:
/data/data/com.google.android.gm/databases/mail.db

Because I was using ActiveAndroid, creating a SQLiteOpenHelper was doing double work. That's why I was seeing 2 databases. To fix this, I deleted the ItemDatabaseHelper class. Then, when I go to the Android Device Monitor to see the database files, I see that Application.db is the only database there, and it has the items I created in it.

Android dev: Creating a sqlite database for word games, no user inputs

I have a simple game where users guess words. Now, I'm thinking using database to store these words to be guessed.
My problem is the tutorials that are available in the web show how to create a database and save user inputs to that database. They create, for example, a DBHelper.java in src, extends it to SQLiteOpenHelper, override the methods. Back to a specific activity, create an instance of DBHelper, then create the db, open the writable, insert user inputs, close db.
But what I think I only need to do is create a database, insert words in it, then make my app retrieve words from this database.
Am i just wondering if what i'm planning to do is right:
1. create a DBHelper.java in src, extends the class to SQLiteOpenHelper
2. define needed Strings like name of database etc.
3. Create a constructor and override the onCreate and onUpgrade methods
4. CREATE A LOADWORDS METHOD this is where i will insert my words to the database.
5. on my main activity(the first screen on my app) I will create an instance of DBHelper and call the onCreate and loadWords method.

// you would want an onCreate and onUpgrade method for best practices,, here's a partial look of what you want...
public class DBManager extends SQLiteOpenHelper
{
static final String TAG = "DBManager";
static final String DB_NAME = "words.db";
static final int DB_VERSION = 1;
static final String TABLE = "words_table";
static final String C_ID = "id";
static final String C_WORD = "word";
public DBManager(Context context)
{
super(context, DB_NAME, null, DB_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db)
{
String sql = "CREATE TABLE " + TABLE + " ("
+ C_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ C_WORD + " TEXT)";
db.execSQL(sql);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
db.execSQL("DROP TABLE IF EXISTS " + TABLE);
onCreate(db);
}
//**** Code Insert Word and Retrieve Word Methods *****//
//**** End Code Insert Word and Retrieve Word Methods *****//
}

how to create database once only, then read and write multiple times from it, SQLite, OpenHelper, Android

I made two classes, the main class that extends Activity and the Database class that holds the database and it's methods. parts of the code from the database class are shown below.
the SQLiteOpenHelper class is a nested class inside the database class. I took it from an example I found on the internet. inside of this nested class is the method,
db.execSQL(SCRIPT_CREATE_DATABASE);
how do I create a new database? If I instantiate the Database class from the Main class like this:
Database db = new Database(this);
does that instantiation automatically instantiate the nested SQLiteOpenHelper class too? so i don't have to explicitly do that.
however for this example of how to create a database, i am confused. if every time I instantiate a new instance calling the addNewRow() method like this:
public void addNewRow(String label, int price){
Database db = new Database(context);
db.openToWrite();
db.insertNewRow(checkBoxStatus, label, price);
db.close();
}
then a new database is created on the "new Database(context)" call, and next I add the info to enter into the columns. and finally call db.close(), however every time i call the addNewRow method shown above, it will instantiate a new database and that also instantiates SQLiteOpenhelper class so a new database is created. that means the last database has been overwritten, and my last row added has been lost, is this correct?
how do i use this Database class to create a Database only once and then read and write things from it with multiple calls like this?
Database db = new Database(context);
db.openToWrite(); or db.openToRead();
// read or update or create new row in database
db.close();
the database class:
public class Database {
public static final String MYDATABASE_NAME = "my_database";
public static final String MYDATABASE_TABLE = "my_table";
public static final int MYDATABASE_VERSION = 1;
public static final String KEY_CHECKBOX_STATUS = "check_box_status";
public static final String KEY_CHECKBOX_LABEL = "check_box_label";
public static final String KEY_PRICE = "price";
//create table MY_DATABASE (ID integer primary key, Content text not null);
private static final String SCRIPT_CREATE_DATABASE =
"CREATE TABLE " + MYDATABASE_TABLE + " (" + "ID INTEGER PRIMARY KEY AUTOINCREMENT, " +
"KEY_CHECKBOX_STATUS INTEGER, " + "KEY_CHECKBOX_LABEL TEXT, " + " KEY_PRICE INTEGER" + ");";
SQLiteDatabase sqLiteDatabase;
SQLiteHelper sqLiteHelper;
Context context;
public Database(Context c){
context = c;
}
// after this all the rest of the methods for get and set of database values
code for the SQLiteOpenHelper class, nested inside of the Database Class:
public class SQLiteHelper extends SQLiteOpenHelper {
public SQLiteHelper(Context context, String name,
CursorFactory factory, int version) {
super(context, name, factory, version);
}
#Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
db.execSQL(SCRIPT_CREATE_DATABASE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
}
}

Yes, every time you instantiate a Database class a SQLiteHelper is instantiate. But the SQLiteHelper onCreate is only called if the database does not exist. You can test this by adding a new column to one of the table and then try to insert a row having value in this column then your app will crash. The error would be "no such column". You then need to clear your data or change the version of your database or uninstall your app to have your change table to be recreated.

Whenever you want to just open your database, you need to use this:
myDatabase = myOpenHelper.getWritableDatabase();
This won't create a new database. It would just return the instance of existing database on which you can do Read/Write operations.
Refer this to get a firm idea of how creating database works in Sqlite. Hope it helps.

private static final String SCRIPT_CREATE_DATABASE =
"CREATE TABLE IF NOT EXISTS " + MYDATABASE_TABLE + " (" + "ID INTEGER PRIMARY KEY AUTOINCREMENT, " +
"KEY_CHECKBOX_STATUS INTEGER, " + "KEY_CHECKBOX_LABEL TEXT, " + " KEY_PRICE INTEGER" + ");";
Use this query while creating the table. It will create the Table if it doesn't exist.

How to join two tables in SQLiteDatabase?

I need to know how to join 2 tables together. I am not sure how to do the joining of tables as I'm new to this.
I've created AnniversaryDBAdapter.class where I create 5 tables in one database. I just need to join 2 tables like join buddiesList table and likes table.
Below is the code of the AnniversaryDBAdapter.class
public class AnniversaryDBAdapter
{
private static final String DATABASE_NAME = "AllTables";
private static final int DATABASE_VERSION = 2;
private static final String CREATE_TABLE_BUDDIESLIST = " create table buddiesList(name_id integer primary key autoincrement, name text not null);";
private static final String CREATE_TABLE_LIKES = " create table likes(name_id integer primary key autoincrement,likes text not null);";
private static final String CREATE_TABLE_DISLIKES = " create table dislikes(name_id integer primary key autoincrement, dislikes text not null);";
private static final String CREATE_TABLE_EVENTS = "create table events(date_id integer primary key autoincrement, name_id text not null, date text not null, title_id text not null, starttime text not null, endtime text not null);";
private static final String CREATE_TABLE_TITLE = "create table titles(title_id integer primary key autoincrement, name text not null, image text not null);";
private final Context context;
private static final String TAG = "DBAdapter";
private DatabaseHelper DBHelper;
private SQLiteDatabase db;
public AnniversaryDBAdapter(Context ctx)
{
this.context = ctx;
DBHelper = new DatabaseHelper(context);
}
private static class DatabaseHelper extends SQLiteOpenHelper
{
DatabaseHelper(Context context)
{
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db)
{
db.execSQL(CREATE_TABLE_BUDDIESLIST);
db.execSQL(CREATE_TABLE_LIKES);
db.execSQL(CREATE_TABLE_EVENTS);
db.execSQL(CREATE_TABLE_TITLE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
Log.w(TAG, "Upgrading database from version "+oldVersion+" to "+newVersion+", which will destroy all old data");
onCreate(db);
}
}
public AnniversaryDBAdapter open() throws SQLException
{
this.db = this.DBHelper.getWritableDatabase();
return this;
}
public void close()
{
this.DBHelper.close();
}
}

Assuming we correct your table layout to something like this:
CREATE TABLE buddiesList(
_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
name TEXT NOT NULL
);
CREATE TABLE likes (
_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
buddy_id INTEGER REFERENCES buddiesList(_id) ON DELETE CASCADE NOT NULL,
likes TEXT NOT NULL
);
Now, in your setup you can create a VIEW of the JOIN between buddiesList and likes, it will act like a normal table when selecting - you just can't update/delete or insert from it (without messing around with TRIGGERs of course).
CREATE VIEW buddyLikes AS
SELECT buddiesList.*, likes._id AS likes_id, likes.likes as likes
FROM buddiesList LEFT JOIN likes ON buddiesList._id=likes.buddy_id;
A View is created using execSQL - just like a table or trigger.
With a view you can select from a join between buddies and likes, returning all buddies and all their likes, like so:
SELECT * from buddyLikes;
which would return something like this:
_id name likes_id likes
1 |Ted |5 |Facebook
1 |Ted |4 |Murder
2 |Ed |1 |Beer
2 |Ed |2 |Cats
2 |Ed |3 |Stock-car racing
3 |Red |6 |Bananarama
BTW: If you want foreign-key support in your database you need to call execSQL
with:
PRAGMA foreign_keys = ON
in your SQLiteOpenHelper#onOpen(SQLiteDatabase db).

Write a query and run with SQLiteDatabase.rawQuery(sql, params).