I'm using ORMLite in my android application. Is there a way when creating the database in the database helper to add some rows, or I must check in the main activity if there is already a database created and then create it and populate it if it doesn't exists.
What I want to achieve: When the application starts for the first time, add some data in the database (when creating the database file).
You can certainly add as much as you like in the onCreate or onUpgrade methods. Once you create the table, generate a DAO and do dao.create(...);.
If you look at the HelloAndroid example application, you can see that it does exactly that.
public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource) {
TableUtils.createTable(connectionSource, SimpleData.class);
// here we try inserting data in the on-create as a test
RuntimeExceptionDao<SimpleData, Integer> dao = getSimpleDataDao();
// create some entries in the onCreate
SimpleData simple = new SimpleData(System.currentTimeMillis());
dao.create(simple);
}
Related
About the update of SQLite in Android.When you change the structure of the datebase,how can we update the datebase without delete the data?
You should override the onUpgrade Method in the SQLiteOpenHelper. You should code something like this.
public void onUpgrade (SQLiteDatabase db,int oldVersion,int newVersion){
String update = ALTER TABLE <table_name> ADD COLUMN <column_name> <column_type>;
db.execSQL(update);
}
Dropping a table, adding a row, inserting/updating/deleting data should be done here.
Alter Table gives you very limited options in performing an update to the database tables. If you want to copy your data into a completely new structure, you should think about creating temporary tables where you can copy data, create the new schema and then copy your data from the temporary tables to the new table, in this upgrade method.
Make sure you have your DB Version numbers correctly updated while creating the DBHelper.
Is there a way to open a pre populated sqlite database using ORMLite. I am sure there is but then my next question is should I be using the following line of codes?
/**
* This is called when the database is first created. Usually you should call createTable statements here to create
* the tables that will store your data.
*/
#Override
public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource) {
try {
Log.i(DatabaseHelper.class.getName(), "onCreate");
TableUtils.createTable(connectionSource, Comment.class);
TableUtils.createTable(connectionSource , Words.class);
} catch (SQLException e) {
Log.e(DatabaseHelper.class.getName(), "Can't create database", e);
throw new RuntimeException(e);
}
Any help would be appreciated.
Is there a way to open a pre populated sqlite database using ORMLite.
To use existing databases, you will need to match your current schema precisely for it to work. You could also increase your database version and use the onUpgrade(...) method to tweak the database to have it match your ORMLite entities.
I am sure there is but then my next question is should I be using the following line of codes?
The onCreate(...) method is called to create new tables if they don't yet exist. To open up existing database (like your subject mentions), the onCreate(...) method will not be called.
When there is new data available to my Android application I need to completely remove all current entries in one of the SQLite database tables and replace them all with the new data. What is the best way to do this?
Would it be best to run
DELETE * FROM my_table
or
run a delete query for every row in the database
or run
database.execSQL(DATABASE_DROP_MY_TABLE);
database.execSQL(DATABASE_CREATE_MY_TABLE);
Where DATABASE_DROP_MY_TABLE is SQL to drop the table and DATABASE_CREATE_MY_TABLE is
SQL to create the table again with no entries.
And then following one of these, insert the new data.
Of course there are probably other ways to do this that I have not thought of.
Assuming you're using SQLiteOpenHelper, you can just close db, delete the whole file and recreate the db:
class MyDatabase extends SQLiteOpenHelper {
public static final String DB_NAME = "wat";
public MyDatabase(Context context) {
super(context, DB_NAME, null, CURRENT_VERSION);
}
}
dbHelper.close(); // dbHelper is your MyDatabase instance
context.deleteDatabase(DB_NAME);
SQLiteDatabase db = dbHelper.getWritableDatabase() // will create empty db
Nice thing about this solution is that you won't have to update table resetting code when you add new tables to your schema. It also correctly recreates indexes you might have added.
I wouldn't complicate things, and simply drop the table with DROP TABLE statement. As the doc say:
The SQLite DROP TABLE statement is used to remove a table definition and all associated data, indexes, triggers, constraints and permission specifications for that table.
You would have clean plate, then create the table again and add your new data.
I'm new to programming. I'm making an Android app and I am at a new hurtle. I am using the SQLiteOpenHelper class to manage my database. Its been great, I am able to create tables, add entries and all that good stuff.
The problem I have is that for one of my tables I want to have an initial 7 entries that keep the same ID and can be replaced by the user. My plan is to use a SQLiteDatabase.replace() method in order to replace these entries. Since I want the entries to be set by me and then edited by the user, that means I want to add entries using the SQLiteOpenHelper class so that these entries are set only when the user installs the app and creates the database. I do not want to make a pre-populated database that I must include in the install package.
My Java skills are god awful so my main question is how do I add entries from inside my SQLiteOpenHelper class? I already know how to add entries in my other classes using the following method that I made:
public long createCategoriesSQLEntry(String name) {
ContentValues cv = new ContentValues();
cv.put(COLUMN_CATEGORIES, name);
return myDatabase.insert(StringCategory_Table, null, cv);
}
Override the onCreate() in the database helper. Like this.
#Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
try{
if(db.isOpen()){
//create tables here
db.execSQL("create table");
db.execSQL("insert row");
db.execSQL("insert row");
}
}
You are database will be installed when for the first time your application is installed. So, you write you data either in file and load it on onCreate method in SQLiteHandling class or just write the data in your java and call it in onCreated method like CyberTengu said.
I have a project with a set of classes that are responsible for their respective database tables.
Each table managing class contains CRUD methods that follow the pattern of get connection, run crud operation, close connection:
public class PersonManager {
SQLiteDatabase db;
DbAdapter dbAdapter; //This is a subclass of SQLiteOpenHelper
public void addPerson(Person person)
{
ContentValues contentValues = new ContentValues();
contentValues.put("email", person.email);
contentValues.put("first_name", person.firstName);
db = dbAdapter.getWritableDatabase();
db.insert("person", null, contentValues);
db.close();
}
...other crud/utility methods omitted...
}
Now that I am upgrading my database via onUpgrade(), I run into database locked issues.
The exact error message follows:
CREATE TABLE android_metadata failed
Failed to setLocale() when constructing, closing the database
android.database.sqlite.SQLiteException: database is locked
It appears that onUpgrade is either meant to:
1 run db.execSQL() calls or
2 use helper classes that use onUpgrade()'s SQLiteDatabase rather than their own
It would be much easier to use my table managing classes to migrate data in onUpgrade() than db.execSQL() statements, or rewrite all my CRUD methods to take onUpgrade()'s SQLiteDatabase.
Am I setting up my database access correctly? If the above code follows the correct pattern, what should I do to fix this issue?
Thanks!
Here's your problem:
db = dbAdapter.getWritableDatabase();
When you're in onUpgrade(), you have to use the SQLiteDatabase handle that onUpgrade() provides you. So your solution is to rewrite your addPerson function to take one more argument -- an SQLiteDatabase handle:
public void addPerson(Person person, SQLiteDatabase db) {...}
If you need to call addPerson() from elsewhere in your project, then keep your current addPerson(Person person) function, have it do that
db = dbAdapter.getWritableDatabase()
call, and pass db to your two-argument version of addPerson().
I didn't get any answers, so I asked on a dev hangout.
According to the Android Developer Hangout Team, onUpgrade is only meant for structure alterations, not really for data migration/manipulation.