@MediumTest
public void testStatementConstraint() throws Exception {
mDatabase.execSQL("CREATE TABLE test (num INTEGER NOT NULL);");
SQLiteStatement statement = mDatabase.compileStatement("INSERT INTO test (num) VALUES (?)");
// Try to insert NULL, which violates the constraint
try {
statement.clearBindings();
statement.execute();
fail("expected exception not thrown");
} catch (SQLiteConstraintException e) {
// expected
}
// Make sure the statement can still be used
statement.bindLong(1, 1);
statement.execute();
statement.close();
Cursor c = mDatabase.query("test", null, null, null, null, null, null);
int numCol = c.getColumnIndexOrThrow("num");
c.moveToFirst();
long num = c.getLong(numCol);
assertEquals(1, num);
c.close();
}
/** update the level and count for the given flashcard in the database. */
private void updateFlashcard(Flashcard fc) {
openDB();
_curDB.beginTransaction();
try {
// Delete old entry if any.
SQLiteStatement dStmt = getCompiledStatement(SQL_DELETE_FCS);
dStmt.bindString(1, fc.getLang1Str());
dStmt.execute();
// insert new state entry.
SQLiteStatement iStmt = getCompiledStatement(SQL_INSERT_FCS);
iStmt.bindString(1, fc.getLang1Str());
iStmt.bindLong(2, fc.getLevel());
iStmt.bindLong(3, fc.getRightGuessCount());
iStmt.execute();
_curDB.setTransactionSuccessful();
} catch (SQLException e) {
MsgDispatcher.sendMessageToUI(
MsgType.MSG_SHOW_ERROR_MSG, 0, 0, "unable to update id=" + fc.getID());
} finally {
_curDB.endTransaction();
}
// this flashcard is no longer used by anyone so release it.
fc.release();
}
protected void saveBookSeriesInfo(long bookId, SeriesInfo seriesInfo) {
if (myGetSeriesIdStatement == null) {
myGetSeriesIdStatement =
myDatabase.compileStatement("SELECT series_id FROM Series WHERE name = ?");
myInsertSeriesStatement =
myDatabase.compileStatement("INSERT OR IGNORE INTO Series (name) VALUES (?)");
myInsertBookSeriesStatement =
myDatabase.compileStatement(
"INSERT OR REPLACE INTO BookSeries (book_id,series_id,book_index) VALUES (?,?,?)");
myDeleteBookSeriesStatement =
myDatabase.compileStatement("DELETE FROM BookSeries WHERE book_id = ?");
}
if (seriesInfo == null) {
myDeleteBookSeriesStatement.bindLong(1, bookId);
myDeleteBookSeriesStatement.execute();
} else {
long seriesId;
try {
myGetSeriesIdStatement.bindString(1, seriesInfo.Name);
seriesId = myGetSeriesIdStatement.simpleQueryForLong();
} catch (SQLException e) {
myInsertSeriesStatement.bindString(1, seriesInfo.Name);
seriesId = myInsertSeriesStatement.executeInsert();
}
myInsertBookSeriesStatement.bindLong(1, bookId);
myInsertBookSeriesStatement.bindLong(2, seriesId);
SQLiteUtil.bindString(
myInsertBookSeriesStatement,
3,
seriesInfo.Index != null ? seriesInfo.Index.toString() : null);
myInsertBookSeriesStatement.execute();
}
}
@Override
public void onCreate(SQLiteDatabase database) {
database.execSQL(
"create table if not exists urlpermission("
+ " id integer primary key autoincrement,"
+ " service_name text,"
+ " url text,"
+ " rule text);");
SQLiteStatement statement =
database.compileStatement(
"insert into urlpermission(service_name, url, rule) values(?,?,?)");
int index = 1;
statement.bindString(index++, "service1");
statement.bindString(index++, "http://www.baidu.com/1");
statement.bindString(index++, "YES");
statement.execute();
index = 1;
statement.bindString(index++, "service2");
statement.bindString(index++, "http://www.baidu.com/2");
statement.bindString(index++, "NO");
statement.execute();
statement.close();
}
List<String> trimCache(long amount) {
ArrayList<String> pathList = new ArrayList<String>(100);
Cursor cursor = null;
final String query = "SELECT contentlength, filepath FROM cache ORDER BY expires ASC";
try {
cursor = mCacheDatabase.rawQuery(query, null);
if (cursor.moveToFirst()) {
int batchSize = 100;
StringBuilder pathStr = new StringBuilder(20 + 16 * batchSize);
pathStr.append("DELETE FROM cache WHERE filepath IN (?");
for (int i = 1; i < batchSize; i++) {
pathStr.append(", ?");
}
pathStr.append(")");
SQLiteStatement statement = null;
try {
statement = mCacheDatabase.compileStatement(pathStr.toString());
// as bindString() uses 1-based index, initialize index to 1
int index = 1;
do {
long length = cursor.getLong(0);
if (length == 0) {
continue;
}
amount -= length;
String filePath = cursor.getString(1);
statement.bindString(index, filePath);
pathList.add(filePath);
if (index++ == batchSize) {
statement.execute();
statement.clearBindings();
index = 1;
}
} while (cursor.moveToNext() && amount > 0);
if (index > 1) {
// there may be old bindings from the previous statement
// if index is less than batchSize, which is Ok.
statement.execute();
}
} catch (IllegalStateException e) {
Log.e(LOGTAG, "trimCache SQLiteStatement", e);
} finally {
if (statement != null) statement.close();
}
}
} catch (IllegalStateException e) {
Log.e(LOGTAG, "trimCache Cursor", e);
} finally {
if (cursor != null) cursor.close();
}
return pathList;
}
private void deleteOldLessons(long groupId) {
try {
mDb.beginTransaction();
mDeleteStatement.bindLong(1, groupId);
mDeleteStatement.execute();
mDeleteInformationStatement.bindLong(1, groupId);
mDeleteInformationStatement.execute();
mDb.setTransactionSuccessful();
} catch (Exception e) {
e.printStackTrace();
} finally {
mDb.endTransaction();
}
}
protected void saveBookAuthorInfo(long bookId, long index, Author author) {
if (myGetAuthorIdStatement == null) {
myGetAuthorIdStatement =
myDatabase.compileStatement(
"SELECT author_id FROM Authors WHERE name = ? AND sort_key = ?");
myInsertAuthorStatement =
myDatabase.compileStatement("INSERT OR IGNORE INTO Authors (name,sort_key) VALUES (?,?)");
myInsertBookAuthorStatement =
myDatabase.compileStatement(
"INSERT OR REPLACE INTO BookAuthor (book_id,author_id,author_index) VALUES (?,?,?)");
}
long authorId;
try {
myGetAuthorIdStatement.bindString(1, author.DisplayName);
myGetAuthorIdStatement.bindString(2, author.SortKey);
authorId = myGetAuthorIdStatement.simpleQueryForLong();
} catch (SQLException e) {
myInsertAuthorStatement.bindString(1, author.DisplayName);
myInsertAuthorStatement.bindString(2, author.SortKey);
authorId = myInsertAuthorStatement.executeInsert();
}
myInsertBookAuthorStatement.bindLong(1, bookId);
myInsertBookAuthorStatement.bindLong(2, authorId);
myInsertBookAuthorStatement.bindLong(3, index);
myInsertBookAuthorStatement.execute();
}
private void insertPhone(
Cursor c,
SQLiteStatement phoneInsert,
SQLiteStatement phoneLookupInsert,
SQLiteStatement hasPhoneUpdate) {
long lastUpdatedContact = -1;
long id = c.getLong(PhonesQuery.PERSON);
String number = c.getString(PhonesQuery.NUMBER);
String normalizedNumber = null;
if (number != null) {
normalizedNumber = PhoneNumberUtils.getStrippedReversed(number);
}
phoneInsert.bindLong(PhoneInsert.RAW_CONTACT_ID, id);
phoneInsert.bindLong(PhoneInsert.MIMETYPE_ID, mPhoneMimetypeId);
bindString(phoneInsert, PhoneInsert.IS_PRIMARY, c.getString(PhonesQuery.ISPRIMARY));
bindString(phoneInsert, PhoneInsert.NUMBER, number);
bindString(phoneInsert, PhoneInsert.TYPE, c.getString(PhonesQuery.TYPE));
bindString(phoneInsert, PhoneInsert.LABEL, c.getString(PhonesQuery.LABEL));
bindString(phoneInsert, PhoneInsert.NORMALIZED_NUMBER, normalizedNumber);
long dataId = insert(phoneInsert);
if (normalizedNumber != null) {
phoneLookupInsert.bindLong(PhoneLookupInsert.RAW_CONTACT_ID, id);
phoneLookupInsert.bindLong(PhoneLookupInsert.DATA_ID, dataId);
phoneLookupInsert.bindString(PhoneLookupInsert.NORMALIZED_NUMBER, normalizedNumber);
insert(phoneLookupInsert);
if (lastUpdatedContact != id) {
lastUpdatedContact = id;
hasPhoneUpdate.bindLong(HasPhoneNumberUpdate.CONTACT_ID, id);
hasPhoneUpdate.execute();
}
}
}
public void saveTile(Tile tile, ByteArrayOutputStream data, boolean success) {
byte[] bytes = null;
if (success) bytes = data.toByteArray();
synchronized (mCacheBuffers) {
data.reset();
mCacheBuffers.add(data);
}
if (dbg) log.debug("store tile {} {}", tile, Boolean.valueOf(success));
if (!success) return;
synchronized (mStmtPutTile) {
mStmtPutTile.bindLong(1, tile.tileX);
mStmtPutTile.bindLong(2, tile.tileY);
mStmtPutTile.bindLong(3, tile.zoomLevel);
mStmtPutTile.bindLong(4, 0);
mStmtPutTile.bindLong(5, 0);
mStmtPutTile.bindBlob(6, bytes);
mStmtPutTile.execute();
mStmtPutTile.clearBindings();
}
}
// @Large
@Suppress
public void testLoadingThreadDelayRegisterData() throws Exception {
mDatabase.execSQL("CREATE TABLE test (_id INTEGER PRIMARY KEY, data INT);");
final int count = 505;
String sql = "INSERT INTO test (data) VALUES (?);";
SQLiteStatement s = mDatabase.compileStatement(sql);
for (int i = 0; i < count; i++) {
s.bindLong(1, i);
s.execute();
}
int maxRead = 500;
int initialRead = 5;
SQLiteCursor c =
(SQLiteCursor) mDatabase.rawQuery("select * from test;", null, initialRead, maxRead);
TestObserver observer = new TestObserver(count, c);
c.getCount();
c.registerDataSetObserver(observer);
if (!observer.quit) {
Looper.loop();
}
c.close();
}
@MediumTest
public void testStatementMultipleBindings() throws Exception {
mDatabase.execSQL("CREATE TABLE test (num INTEGER, str TEXT);");
SQLiteStatement statement =
mDatabase.compileStatement("INSERT INTO test (num, str) VALUES (?, ?)");
for (long i = 0; i < 10; i++) {
statement.bindLong(1, i);
statement.bindString(2, Long.toHexString(i));
statement.execute();
}
statement.close();
Cursor c = mDatabase.query("test", null, null, null, null, null, "ROWID");
int numCol = c.getColumnIndexOrThrow("num");
int strCol = c.getColumnIndexOrThrow("str");
assertTrue(c.moveToFirst());
for (long i = 0; i < 10; i++) {
long num = c.getLong(numCol);
String str = c.getString(strCol);
assertEquals(i, num);
assertEquals(Long.toHexString(i), str);
c.moveToNext();
}
c.close();
}
/**
* Called by the ManageLocations screen to update a location in the database
*
* @param id
* @param locationName
* @param coordinates
* @param description
* @return
*/
public boolean updateLocationData(
int id, String locationName, String coordinates, String description) {
boolean success = false;
SQLiteDatabase db = getReadableDatabase();
String sql =
"UPDATE locations SET locationName = ?, coordinates = ?, description = ? where _id = ?";
SQLiteStatement sqlStatement = db.compileStatement(sql);
sqlStatement.bindString(1, locationName);
sqlStatement.bindString(2, coordinates);
sqlStatement.bindString(3, description);
sqlStatement.bindLong(4, id);
db.beginTransaction();
try {
sqlStatement.execute();
db.setTransactionSuccessful();
success = true;
} catch (SQLException ex) {
ex.printStackTrace();
} finally {
db.endTransaction();
sqlStatement.close();
db.close();
}
return success;
}
@Override
public void changeStoredSamplesType(
int timestampFrom, int timestampTo, byte kind, SampleProvider provider) {
try (SQLiteDatabase db = this.getReadableDatabase()) {
String sql =
"UPDATE "
+ TABLE_GBACTIVITYSAMPLES
+ " SET "
+ KEY_TYPE
+ "= ? WHERE "
+ KEY_PROVIDER
+ " = ? AND "
+ KEY_TIMESTAMP
+ " >= ? AND "
+ KEY_TIMESTAMP
+ " < ? ;"; // do not use BETWEEN because the range is inclusive in that case!
SQLiteStatement statement = db.compileStatement(sql);
statement.bindLong(1, kind);
statement.bindLong(2, provider.getID());
statement.bindLong(3, timestampFrom);
statement.bindLong(4, timestampTo);
statement.execute();
}
}
/** Insert a set of flashcards (linked list) in a single transaction. */
private void insertFlashcardSet(Flashcard head) {
openDB();
SQLiteStatement stmt = getCompiledStatement(SQL_INSERT_FC);
boolean gotError = false;
_curDB.beginTransaction();
try {
for (Flashcard fc = head; fc != null; fc = Flashcard.Chain.getNext(fc)) {
stmt.bindLong(1, _importState.getRandomId());
stmt.bindString(2, fc.getLang1Str());
stmt.bindString(3, fc.getLang2Str());
stmt.execute();
}
_curDB.setTransactionSuccessful();
} catch (SQLException e) {
gotError = true;
MsgDispatcher.sendMessageToUI(MsgType.MSG_SHOW_ERROR_MSG, 0, 0, "unable to insert fc");
} finally {
_curDB.endTransaction();
}
Flashcard.Chain.releaseChain(head);
// tell controller to send us more data if insert went fine.
if (!gotError) {
MsgDispatcher.sendMessageToController(MsgType.MSG_CONTINUE_IMPORT, 0, 0, null);
}
}
/**
* Adds or updates room.
*
* @param account
* @param room
* @param nickname
* @param password
* @param join
*/
void write(String account, String room, String nickname, String password, boolean join) {
synchronized (writeLock) {
if (writeStatement == null) {
SQLiteDatabase db = databaseManager.getWritableDatabase();
writeStatement =
db.compileStatement(
"INSERT OR REPLACE INTO "
+ NAME
+ " ("
+ Fields.ACCOUNT
+ ", "
+ Fields.ROOM
+ ", "
+ Fields.NICKNAME
+ ", "
+ Fields.PASSWORD
+ ", "
+ Fields.NEED_JOIN
+ ") VALUES (?, ?, ?, ?, ?);");
}
writeStatement.bindString(1, account);
writeStatement.bindString(2, room);
writeStatement.bindString(3, nickname);
writeStatement.bindString(4, password);
writeStatement.bindLong(5, join ? 1 : 0);
writeStatement.execute();
}
}
public void updateHomeWork(HomeWork hw) {
try {
mDb.beginTransaction();
if (hw != null) {
mUpdateHomeWorkStatement.clearBindings();
if (hw.isComplite()) {
mUpdateHomeWorkStatement.bindLong(1, 1);
NotificationManager.getInstance().removeNotification(hw);
} else {
mUpdateHomeWorkStatement.bindLong(1, 0);
NotificationManager.getInstance().addNewNotification(hw);
}
if (hw.getMessage() != null) {
mUpdateHomeWorkStatement.bindString(2, hw.getMessage());
}
if (hw.getMessage() != null) {
mUpdateHomeWorkStatement.bindBlob(3, Slipper.serializeObject(hw.getImages()));
}
mUpdateHomeWorkStatement.bindLong(4, hw.getId());
mUpdateHomeWorkStatement.execute();
}
mDb.setTransactionSuccessful();
} catch (Exception e) {
e.printStackTrace();
} finally {
mDb.endTransaction();
}
}
@Override
public void addGBActivitySamples(ActivitySample[] activitySamples) {
try (SQLiteDatabase db = this.getWritableDatabase()) {
String sql =
"INSERT INTO "
+ TABLE_GBACTIVITYSAMPLES
+ " ("
+ KEY_TIMESTAMP
+ ","
+ KEY_PROVIDER
+ ","
+ KEY_INTENSITY
+ ","
+ KEY_STEPS
+ ","
+ KEY_TYPE
+ ")"
+ " VALUES (?,?,?,?,?);";
SQLiteStatement statement = db.compileStatement(sql);
db.beginTransaction();
for (ActivitySample activitySample : activitySamples) {
statement.clearBindings();
statement.bindLong(1, activitySample.getTimestamp());
statement.bindLong(2, activitySample.getProvider().getID());
statement.bindLong(3, activitySample.getRawIntensity());
statement.bindLong(4, activitySample.getSteps());
statement.bindLong(5, activitySample.getRawKind());
statement.execute();
}
db.setTransactionSuccessful();
db.endTransaction();
}
}
private static void migrateConversation(
Context context,
MasterSecret masterSecret,
Handler handler,
long theirThreadId,
long ourThreadId) {
SmsDatabase ourSmsDatabase = DatabaseFactory.getSmsDatabase(context);
Cursor cursor = null;
try {
Uri uri = Uri.parse("content://sms/conversations/" + theirThreadId);
cursor = context.getContentResolver().query(uri, null, null, null, null);
SQLiteDatabase transaction = ourSmsDatabase.beginTransaction();
SQLiteStatement statement = ourSmsDatabase.createInsertStatement(transaction);
while (cursor != null && cursor.moveToNext()) {
getContentValuesForRow(context, masterSecret, cursor, ourThreadId, statement);
statement.execute();
Message msg =
handler.obtainMessage(SECONDARY_PROGRESS_UPDATE, 10000 / cursor.getCount(), 0);
handler.sendMessage(msg);
}
ourSmsDatabase.endTransaction(transaction);
DatabaseFactory.getThreadDatabase(context).update(ourThreadId);
DatabaseFactory.getThreadDatabase(context).notifyConversationListeners(ourThreadId);
} finally {
if (cursor != null) cursor.close();
}
}
public void addTerms(ArrayList<Terms> termList, User usr) {
System.out.println("Terms StartUp : " + System.currentTimeMillis());
if (!isTermsAvailableForCompany(usr.getCompanyId())) {
deleteTerms();
SQLiteDatabase db = this.getWritableDatabase();
try {
db.beginTransaction();
SQLiteStatement statement = db.compileStatement(this.TERMS_QUERY);
for (Terms terms : termList) {
statement.bindString(1, terms.description);
statement.bindLong(2, terms.languageId);
statement.bindString(3, terms.term);
statement.bindString(4, usr.getCompanyId());
statement.execute();
statement.clearBindings();
}
db.setTransactionSuccessful();
} catch (Exception e) {
// TODO: handle exception
} finally {
db.endTransaction();
db.close();
}
}
System.out.println("Terms End : " + System.currentTimeMillis());
}
/**
* Called by ManageLocations screen to add a location to the database
*
* @param locationName
* @param coordinates
* @param description
* @return
*/
public boolean addLocationData(String locationName, String coordinates, String description) {
boolean success = false;
SQLiteDatabase db = getReadableDatabase();
SQLiteStatement sqlStatement =
db.compileStatement(
"INSERT INTO locations (locationName, coordinates, description) VALUES (?, ?, ?)");
sqlStatement.bindString(1, locationName);
sqlStatement.bindString(2, coordinates);
sqlStatement.bindString(3, description);
db.beginTransaction();
try {
sqlStatement.execute();
db.setTransactionSuccessful();
success = true;
} catch (SQLException ex) {
ex.printStackTrace();
} finally {
db.endTransaction();
sqlStatement.close();
db.close();
}
return success;
}
public void upsertContentWifiNode(
ContentValues values, String selection, String[] selectionArgs) {
long rowID = getContentId(values.getAsString(SizzoSchema.CONTENTS.Columns.UID));
if (rowID > 0) {
if (mStatementUpdateWifiNode == null) {
mStatementUpdateWifiNode =
getWritableDatabase()
.compileStatement(
"UPDATE "
+ SizzoSchema.CONTENTS.TABLE
+ " SET "
+ SizzoSchema.CONTENTS.Columns.TITLE
+ "=?, "
+ SizzoSchema.CONTENTS.Columns.DETAIL
+ "=?, "
+ SizzoSchema.CONTENTS.Columns.TYPE
+ "=?, "
+ SizzoSchema.CONTENTS.Columns.LASTUPDATEDDATE
+ "=date('now')"
+ " WHERE "
+ SizzoSchema.CONTENTS.Columns.UID
+ "=?");
}
bindString(
mStatementUpdateWifiNode, 1, values.getAsString(SizzoSchema.CONTENTS.Columns.TITLE));
bindString(
mStatementUpdateWifiNode, 2, values.getAsString(SizzoSchema.CONTENTS.Columns.DETAIL));
bindString(mStatementUpdateWifiNode, 3, SizzoSchema.CONTENTS.Types.WIFI.name());
bindString(mStatementUpdateWifiNode, 4, values.getAsString(SizzoSchema.CONTENTS.Columns.UID));
mStatementUpdateWifiNode.execute();
}
}
private int update(String statement, Object[] args, FieldType[] argFieldTypes, String label)
throws SQLException {
SQLiteStatement stmt = null;
try {
stmt = db.compileStatement(statement);
bindArgs(stmt, args, argFieldTypes);
stmt.execute();
} catch (android.database.SQLException e) {
throw SqlExceptionUtil.create("updating database failed: " + statement, e);
} finally {
closeQuietly(stmt);
stmt = null;
}
int result;
try {
stmt = db.compileStatement("SELECT CHANGES()");
result = (int) stmt.simpleQueryForLong();
} catch (android.database.SQLException e) {
// ignore the exception and just return 1
result = 1;
} finally {
closeQuietly(stmt);
}
logger.trace("{} statement is compiled and executed, changed {}: {}", label, result, statement);
return result;
}
private void updateTables6() {
myDatabase.execSQL("ALTER TABLE Bookmarks ADD COLUMN model_id TEXT");
myDatabase.execSQL("ALTER TABLE Books ADD COLUMN file_id INTEGER");
myDatabase.execSQL("DELETE FROM Files");
final FileInfoSet infoSet = new FileInfoSet();
Cursor cursor = myDatabase.rawQuery("SELECT file_name FROM Books", null);
while (cursor.moveToNext()) {
infoSet.check(ZLFile.createFileByPath(cursor.getString(0)).getPhysicalFile(), false);
}
cursor.close();
infoSet.save();
cursor = myDatabase.rawQuery("SELECT book_id,file_name FROM Books", null);
final SQLiteStatement deleteStatement =
myDatabase.compileStatement("DELETE FROM Books WHERE book_id = ?");
final SQLiteStatement updateStatement =
myDatabase.compileStatement("UPDATE Books SET file_id = ? WHERE book_id = ?");
while (cursor.moveToNext()) {
final long bookId = cursor.getLong(0);
final long fileId = infoSet.getId(ZLFile.createFileByPath(cursor.getString(1)));
if (fileId == -1) {
deleteStatement.bindLong(1, bookId);
deleteStatement.execute();
} else {
updateStatement.bindLong(1, fileId);
updateStatement.bindLong(2, bookId);
updateStatement.execute();
}
}
cursor.close();
myDatabase.execSQL("ALTER TABLE Books RENAME TO Books_Obsolete");
myDatabase.execSQL(
"CREATE TABLE Books("
+ "book_id INTEGER PRIMARY KEY,"
+ "encoding TEXT,"
+ "language TEXT,"
+ "title TEXT NOT NULL,"
+ "file_id INTEGER UNIQUE NOT NULL REFERENCES Files(file_id))");
myDatabase.execSQL(
"INSERT INTO Books (book_id,encoding,language,title,file_id) SELECT book_id,encoding,language,title,file_id FROM Books_Obsolete");
myDatabase.execSQL("DROP TABLE Books_Obsolete");
}
protected void deleteAllBookTags(long bookId) {
if (myDeleteBookTagsStatement == null) {
myDeleteBookTagsStatement =
myDatabase.compileStatement("DELETE FROM BookTag WHERE book_id = ?");
}
myDeleteBookTagsStatement.bindLong(1, bookId);
myDeleteBookTagsStatement.execute();
}
private void delete(String id) {
pendingCancelations.remove(id);
db.beginTransaction();
try {
SQLiteStatement stmt = sqlHelper.getDeleteStatement();
stmt.clearBindings();
stmt.bindString(1, id);
stmt.execute();
SQLiteStatement deleteTagsStmt = sqlHelper.getDeleteJobTagsStatement();
deleteTagsStmt.bindString(1, id);
deleteTagsStmt.execute();
db.setTransactionSuccessful();
jobStorage.delete(id);
} finally {
db.endTransaction();
}
}
public void executeSQL(String sql) {
Context context = getContext();
final SQLiteDatabase db = getDatabaseByDefaultPath(context);
SQLiteStatement statement = db.compileStatement(sql);
if (statement != null) {
statement.execute();
}
}
protected void removeFromFavorites(long bookId) {
if (myRemoveFromFavoritesStatement == null) {
myRemoveFromFavoritesStatement =
myDatabase.compileStatement("DELETE FROM Favorites WHERE book_id = ?");
}
myRemoveFromFavoritesStatement.bindLong(1, bookId);
myRemoveFromFavoritesStatement.execute();
}
protected void addToFavorites(long bookId) {
if (myAddToFavoritesStatement == null) {
myAddToFavoritesStatement =
myDatabase.compileStatement("INSERT OR IGNORE INTO Favorites(book_id) VALUES (?)");
}
myAddToFavoritesStatement.bindLong(1, bookId);
myAddToFavoritesStatement.execute();
}
private void deleteVisitedHyperlinks(long bookId) {
if (myDeleteVisitedHyperlinksStatement == null) {
myDeleteVisitedHyperlinksStatement =
myDatabase.compileStatement("DELETE FROM VisitedHyperlinks WHERE book_id = ?");
}
myDeleteVisitedHyperlinksStatement.bindLong(1, bookId);
myDeleteVisitedHyperlinksStatement.execute();
}
protected boolean insertIntoBookList(long bookId) {
if (myInsertIntoBookListStatement == null) {
myInsertIntoBookListStatement =
myDatabase.compileStatement("INSERT OR IGNORE INTO BookList(book_id) VALUES (?)");
}
myInsertIntoBookListStatement.bindLong(1, bookId);
myInsertIntoBookListStatement.execute();
return true;
}