The template I use for SQLite database interaction is the following:
The helper for creating database:
public class DatabaseHelper extends SQLiteOpenHelper
{
private static final String DATABASE_NAME = "database.db";
private static final int DATABASE_VERSION = 1;
public DatabaseHelper(Context context)
{
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase database)
{
Table1.onCreate(database);
Table2.onCreate(database);
Table3.onCreate(database);
}
@Override
public void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion)
{
Table1.onUpgrade(database, oldVersion, newVersion);
Table2.onUpgrade(database, oldVersion, newVersion);
Table3.onUpgrade(database, oldVersion, newVersion);
}
}
A table as an example:
public class Table1
{
public static final String TABLE_TABLE1 = "table1";
public static final String COLUMN_ID = "_id";
public static final String COLUMN_NAME = "name";
public static final String COLUMN_PHONENUMBER = "phoneNumber";
public static final String COLUMN_EMAIL = "email";
private static final String DATABASE_CREATE = "create table " + TABLE_TABLE1 + "("
+ COLUMN_ID + " integer primary key autoincrement, "
+ COLUMN_NAME + " text not null, "
+ COLUMN_PHONENUMBER + " text not null, "
+ COLUMN_EMAIL + " text not null, "
+ ");";
public static void onCreate(SQLiteDatabase database)
{
database.execSQL(DATABASE_CREATE);
}
public static void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion)
{
Log.w(Table1.class.getName(), "Upgrading from version " + oldVersion + " to " + newVersion);
database.execSQL("DROP TABLE IF EXISTS " + TABLE_TABLE1);
onCreate(database);
}
}
Operations for table:
public class Table1DataSource
{
// Database fields
private SQLiteDatabase database;
private DatabaseHelper dbHelper;
private String[] allColumns = { Table1.COLUMN_ID, Table1.COLUMN_NAME,
Table1.COLUMN_PHONENUMBER, Table1.COLUMN_EMAIL };
public Table1DataSource(Context context)
{
dbHelper = new DatabaseHelper(context);
}
public void open() throws SQLException
{
database = dbHelper.getWritableDatabase();
}
public void close()
{
dbHelper.close();
}
private EmployeeDB cursorToEmployee(Cursor cursor)
{
EmployeeDB Employee = new EmployeeDB();
Employee.setId(cursor.getLong(0));
Employee.setName(cursor.getString(1));
Employee.setPhoneNumber(cursor.getString(2));
Employee.setEmail(cursor.getString(3));
return Employee;
}
public EmployeeDB createEmployee(String name, String phoneNumber, String email)
{
ContentValues values = new ContentValues();new
values.put(Table1.COLUMN_NAME, name);
values.put(Table1.COLUMN_PHONENUMBER, phoneNumber);
values.put(Table1.COLUMN_EMAIL, email);
long insertId = database.insert(Table1.TABLE_TABLE1, null, values);
Cursor cursor = database.query(Table1.TABLE_TABLE1, allColumns, Table1.COLUMN_ID
+ " = " + insertId, null, null, null, null);
cursor.moveToFirst();
EmployeeDB newEmployee = cursorToEmployee(cursor);
cursor.close();
return newEmployee;
}
public void updateEmployee(EmployeeDB employee)
{
ContentValues values = new ContentValues();
values.put(Table1.COLUMN_NAME, name);
values.put(Table1.COLUMN_PHONENUMBER, phoneNumber);
values.put(Table1.COLUMN_EMAIL, email);
database.update(Table1.TABLE_TABLE1, values, Table1.COLUMN_ID + " = ?", new String[]{""+employee.getId()});
}
public void deleteEmployee(EmployeeDB Employee)
{
long id = Employee.getId();
database.delete(EmployeeTable.TABLE_EMPLOYEE, EmployeeTable.COLUMN_ID + " = " + id, null);
}
public Cursor getAllEmployees()
{
return database.query(EmployeeTable.TABLE_EMPLOYEE, allColumns, null, null, null, null, null);
}
public EmployeeDB findEmployeeById(long id)
{
EmployeeDB employee = null;
Cursor cursor = database.query(EmployeeTable.TABLE_EMPLOYEE, allColumns, EmployeeTable.COLUMN_ID + " = ?", new String[] {""+id}, null, null, null);
if(cursor.moveToFirst())
{
employee = cursorToEmployee(cursor);
}
return employee;
}
public List getAllEmployeesList()
{
List Employees = new ArrayList();
Cursor cursor = getAllEmployees();
if (cursor.moveToFirst())
{
do
{
EmployeeDB Employee = cursorToEmployee(cursor);
Employees.add(Employee);
}
while (cursor.moveToNext());
}
cursor.close();
return Employees;
}
}
EDIT: Slightly more updated version (revisited in 2017-04-29):
public class DatabaseManager
extends SQLiteOpenHelper {
public interface Table {
String getTableName();
Fields[] getFields();
void onCreate(SQLiteDatabase database);
void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion);
}
public interface Fields {
String getFieldName();
String getFieldType();
String getFieldAdditional();
}
public interface QueryDefinition {
Cursor query(SQLiteDatabase database, Table table, String[] allFields);
}
private static final String DATABASE_NAME = "database.db";
private static final int DATABASE_VERSION = 1;
private final List tables;
private SQLiteDatabase database;
public DatabaseManager(Context appContext, List tables) {
super(appContext, DATABASE_NAME, null, DATABASE_VERSION);
this.tables = tables;
this.database = getWritableDatabase();
}
@Override
public void onCreate(SQLiteDatabase database) {
for(Table table : tables) {
table.onCreate(database);
}
}
@Override
public void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion) {
for(Table table : tables) {
table.onUpgrade(database, oldVersion, newVersion);
}
}
public interface Transaction {
void execute(SQLiteDatabase sqLiteDatabase);
}
public interface Mapper {
T from(Cursor cursor);
ContentValues from(ContentValues contentValues, T t);
}
public void executeTransaction(Transaction transaction) {
try {
database.beginTransaction();
transaction.execute(database);
database.setTransactionSuccessful();
} finally {
if(database.inTransaction()) {
database.endTransaction();
}
}
}
public List findAll(Table table, Mapper mapper) {
return findAll(table,
mapper, (database, _table, allFields) -> database.query(_table.getTableName(), allFields, null, null, null, null, null));
}
public List findAll(Table table, Mapper mapper, QueryDefinition queryDefinition) {
String[] allFields = extractFieldsFromTable(table);
Cursor cursor = queryDefinition.query(database, table, allFields);
List list = collectObjectFromCursor(mapper, cursor);
cursor.close();
return list;
}
private List collectObjectFromCursor(Mapper mapper, Cursor cursor) {
List list = new LinkedList<>();
if(cursor.moveToFirst()) {
do {
T object = mapper.from(cursor);
list.add(object);
} while(cursor.moveToNext());
}
return new ArrayList<>(list);
}
@NonNull
private String[] extractFieldsFromTable(Table table) {
Fields[] _fields = table.getFields();
String[] fields = new String[_fields.length];
int i = 0;
for(Fields field : _fields) {
fields[i++] = field.getFieldName();
}
return fields;
}
}
public abstract class BaseTable
implements DatabaseManager.Table {
@Override
public void onCreate(SQLiteDatabase database) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("CREATE TABLE ");
stringBuilder.append(getTableName());
stringBuilder.append("(");
DatabaseManager.Fields[] fields = getFields();
int size = fields.length;
int i = 0;
for(DatabaseManager.Fields field : fields) {
stringBuilder.append(field.getFieldName());
stringBuilder.append(" ");
stringBuilder.append(field.getFieldType());
stringBuilder.append(" ");
if(field.getFieldAdditional() != null) {
stringBuilder.append(field.getFieldAdditional());
}
if(i < size - 1) {
stringBuilder.append(",");
}
i++;
}
stringBuilder.append(");");
database.execSQL(stringBuilder.toString());
}
@Override // TODO: implement migration
public void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion) {
Log.w("Table[" + getTableName() + "]", "Upgrading from version " + oldVersion + " to " + newVersion);
database.execSQL("DROP TABLE IF EXISTS " + getTableName());
onCreate(database);
}
}
public enum Tables {
CAT(new CatTable());
private DatabaseManager.Table table;
Tables(DatabaseManager.Table table) {
this.table = table;
}
public T getTable() {
//noinspection unchecked
return (T) table;
}
public static List getTables() {
Tables[] _tables = Tables.values();
List tables = new ArrayList<>(_tables.length);
for(Tables table : _tables) {
tables.add(table.table);
}
return tables;
}
}
public class CatTable
extends BaseTable {
public static final String NAME = "cat";
public enum Fields
implements DatabaseManager.Fields {
ID("_id", "text", "primary key"), //"integer", "primary key autoincrement"),
URL("url", "text", "not null"),
SOURCE_URL("sourceUrl", "text", "not null");
private String fieldName;
private String fieldType;
private String fieldAdditional;
Fields(String fieldName, String fieldType, String fieldAdditional) {
this.fieldName = fieldName;
this.fieldType = fieldType;
this.fieldAdditional = fieldAdditional;
}
public String getFieldName() {
return fieldName;
}
public String getFieldType() {
return fieldType;
}
public String getFieldAdditional() {
return fieldAdditional;
}
}
@Override
public String getTableName() {
return NAME;
}
@Override
public DatabaseManager.Fields[] getFields() {
return Fields.values();
}
}
public class CatMapper
implements DatabaseManager.Mapper {
@Override
public Cat from(Cursor cursor) {
return Cat.create(cursor.getString(0), cursor.getString(1), cursor.getString(2));
}
@Override
public ContentValues from(ContentValues contentValues, Cat cat) {
contentValues.put(CatTable.Fields.ID.getFieldName(), cat.id());
contentValues.put(CatTable.Fields.URL.getFieldName(), cat.url());
contentValues.put(CatTable.Fields.SOURCE_URL.getFieldName(), cat.sourceUrl());
}
}
public class CatDao {
CatTable catTable;
CatMapper catMapper;
DatabaseManager databaseManager;
public CatDao(CatTable catTable, CatMapper catMapper, DatabaseManager databaseManager) {
this.catTable = catTable;
this.catMapper = catMapper;
this.databaseManager = databaseManager;
}
public List findAll() {
return databaseManager.findAll(catTable, catMapper);
}
public void insert(List cats) {
databaseManager.executeTransaction(sqLiteDatabase -> {
ContentValues contentValues = new ContentValues();
for(Cat cat : cats) {
contentValues = mapper.from(contentValues, cat);
sqLiteDatabase.insertWithOnConflict(catTable.getTableName(), null, contentValues, SQLiteDatabase.CONFLICT_REPLACE);
}
});
}
}
@AutoValue
public abstract class Cat {
public abstract String id();
public abstract String url();
public abstract String sourceUrl();
public static Cat create(String id, String url, String sourceUrl) {
return new AutoValue_Cat.Builder().setId(id).setUrl(url).setSourceUrl(sourceUrl).build();
}
public Builder toBuilder() {
return new AutoValue_Cat.Builder(this);
}
@AutoValue.Builder
public abstract static class Builder {
public abstract Builder setId(String id);
public abstract Builder setUrl(String url);
public abstract Builder setSourceUrl(String sourceUrl);
public abstract Cat build();
}
}
