Java Code Examples for android.database.sqlite.SQLiteDatabase#setTransactionSuccessful()

The following examples show how to use android.database.sqlite.SQLiteDatabase#setTransactionSuccessful() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
public synchronized void deleteAssignments(Category category) {
    SQLiteDatabase database = getWritableDatabase();
    database.beginTransaction();
    try {
        database.execSQL(" UPDATE " + tableName
                        + " SET " + AssignmentSchema.STATUS + " = " + Status.DELETED.id + ", "
                        + AssignmentSchema.LAST_MODIFIED_TIME + " = ? "
                        + " WHERE " + AssignmentSchema.CATEGORY_CODE + " = " + category.getCode()
                        + " AND " + AssignmentSchema.USER_ID + " = " + userId,
                new String[]{String.valueOf(System.currentTimeMillis())});
        database.setTransactionSuccessful();
    } finally {
        database.endTransaction();
        closeDatabase(database);
    }
}
 
Example 2
public void setAccess(long id, int block) {
    lock.writeLock().lock();
    try {
        SQLiteDatabase db = this.getWritableDatabase();
        db.beginTransactionNonExclusive();
        try {
            ContentValues cv = new ContentValues();
            cv.put("block", block);
            cv.put("allowed", -1);

            if (db.update("access", cv, "ID = ?", new String[]{Long.toString(id)}) != 1)
                Log.e(TAG, "Set access failed");

            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
    } finally {
        lock.writeLock().unlock();
    }

    notifyAccessChanged();
}
 
Example 3
Source Project: YoDao   File: BaseDao.java    License: Apache License 2.0 6 votes vote down vote up
@Override
public int delete(List<T> entities) {
	int count = 0;
	SQLiteDatabase db = getDb(true);
	db.beginTransaction();
	try {
		for (T item : entities) {
			count += delete(item);
		}
		db.setTransactionSuccessful();
	} catch (Throwable e) {
		e.printStackTrace();
	} finally {
		db.endTransaction();
	}
	return count;
}
 
Example 4
@Override public void ok() {
    SparseArray<Long> deposites = mEnvelopes.getDeposites();
    String description = mDescription.getText().toString();
    String frequency = null;
    int l = deposites.size();
    SQLiteDatabase db = (new EnvelopesOpenHelper(getActivity())).getWritableDatabase();
    db.beginTransaction();
    try {
        ContentValues values = new ContentValues();
        for (int i = 0; i != l; ++i) {
            int id = deposites.keyAt(i);
            long centsDeposited = deposites.valueAt(i);
            EnvelopesOpenHelper.deposite(db, id, centsDeposited, description, frequency);
            values.put("lastPaycheckCents", centsDeposited);
            db.update("envelopes", values, "_id = ?", new String[] {
                Integer.toString(id)
            });
        }
        db.setTransactionSuccessful();
        getActivity().getContentResolver().notifyChange(EnvelopesOpenHelper.URI, null);
    } finally {
        db.endTransaction();
        db.close();
    }
}
 
Example 5
private void executeCreateIndex(SQLiteDatabase db) {
	db.beginTransaction();
	try {
		for (TableInfo tableInfo : Cache.getTableInfos()) {
			String[] definitions = SQLiteUtils.createIndexDefinition(tableInfo);

			for (String definition : definitions) {
				db.execSQL(definition);
			}
		}
		db.setTransactionSuccessful();
	}
	finally {
		db.endTransaction();
	}
}
 
Example 6
@SuppressWarnings("deprecation")
public static <T> void saveInTx(Collection<T> objects) {
    SQLiteDatabase sqLiteDatabase = getSugarDataBase();
    try {
        sqLiteDatabase.beginTransaction();
        sqLiteDatabase.setLockingEnabled(false);
        for (T object: objects) {
            save(object);
        }
        sqLiteDatabase.setTransactionSuccessful();
    } catch (Exception e) {
        Log.i(SUGAR, "Error in saving in transaction " + e.getMessage());
    } finally {
        sqLiteDatabase.endTransaction();
        sqLiteDatabase.setLockingEnabled(true);
    }
}
 
Example 7
@Override
public Uri insert(Uri uri, ContentValues values) {
    synchronized (obj) {
        SQLiteDatabase db = getDBHelper().getWritableDatabase();
        long rowId = 0;
        db.beginTransaction();
        try {
            rowId = db.insert(matchTable(uri), null, values);
            db.setTransactionSuccessful();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            db.endTransaction();
        }
        if (rowId > 0) {
            Uri returnUri = ContentUris.withAppendedId(uri, rowId);
            getContext().getContentResolver().notifyChange(uri, null);
            return returnUri;
        }
        throw new SQLException("Failed to insert row into " + uri);
    }
}
 
Example 8
public int deleteAllMeasurements() {
    Timber.d("deleteAllMeasurements(): Deleting all measurements");
    SQLiteDatabase db = helper.getWritableDatabase();
    db.beginTransaction();
    int deletedCellSignals = 0;
    try {
        deletedCellSignals = db.delete(CellSignalsTable.TABLE_NAME, "1", null);
        int deletedMeasurements = db.delete(MeasurementsTable.TABLE_NAME, "1", null);
        db.setTransactionSuccessful();
        Timber.d("deleteAllMeasurements(): Deleted %s cell signals, %s measurements", deletedCellSignals, deletedMeasurements);
    } finally {
        invalidateCache();
        db.endTransaction();
    }
    return deletedCellSignals;
}
 
Example 9
@Override
public Metrics runCase() {
    mDbHelper = new DbHelper(App.getInstance(), IntegerInsertsRawTransactionCase.class.getSimpleName());
    Metrics result = new Metrics(getClass().getSimpleName()+" ("+mInsertions+" insertions)", mTestSizeIndex);
    SQLiteDatabase db = mDbHelper.getWritableDatabase();
    result.started();
    db.beginTransaction();
    Object[] values = new Object[1];
    for (int i = 0; i < mInsertions; i++) {
        values[0] = mRandom.nextInt();
        db.execSQL("INSERT INTO inserts_1 (val) VALUES (?)", values);
    }
    db.setTransactionSuccessful();
    db.endTransaction();
    result.finished();
    return result;
}
 
Example 10
public void deleteMessageInConversation(Message message) {
    long start = SystemClock.elapsedRealtime();
    final SQLiteDatabase db = this.getWritableDatabase();
    db.beginTransaction();
    ContentValues values = new ContentValues();
    values.put(Message.DELETED, "1");
    String[] args = {message.getUuid()};
    int rows = db.update("messages", values, "uuid =?", args);
    db.setTransactionSuccessful();
    db.endTransaction();
    Log.d(Config.LOGTAG, "deleted " + rows + " message in " + (SystemClock.elapsedRealtime() - start) + "ms");
}
 
Example 11
Source Project: Cangol-appcore   File: DaoImpl.java    License: Apache License 2.0 5 votes vote down vote up
@Override
public int deleteAll() throws SQLException {
    final SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
    int result = 0;
    try {
        db.beginTransaction();
        result = db.delete(mTableName, null, null);
        db.setTransactionSuccessful();
    } catch (Exception e) {
        throw new SQLException(mTableName + " error=" + e, e);
    } finally {
        db.endTransaction();
    }
    return result;
}
 
Example 12
/**
 * Handles requests to insert a set of new rows. In Sunshine, we are only going to be
 * inserting multiple rows of data at a time from a weather forecast. There is no use case
 * for inserting a single row of data into our ContentProvider, and so we are only going to
 * implement bulkInsert. In a normal ContentProvider's implementation, you will probably want
 * to provide proper functionality for the insert method as well.
 *
 * @param uri    The content:// URI of the insertion request.
 * @param values An array of sets of column_name/value pairs to add to the database.
 *               This must not be {@code null}.
 *
 * @return The number of values that were inserted.
 */
@Override
public int bulkInsert(@NonNull Uri uri, @NonNull ContentValues[] values) {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();

    switch (sUriMatcher.match(uri)) {

        case CODE_WEATHER:
            db.beginTransaction();
            int rowsInserted = 0;
            try {
                for (ContentValues value : values) {
                    long weatherDate =
                            value.getAsLong(WeatherContract.WeatherEntry.COLUMN_DATE);
                    if (!SunshineDateUtils.isDateNormalized(weatherDate)) {
                        throw new IllegalArgumentException("Date must be normalized to insert");
                    }

                    long _id = db.insert(WeatherContract.WeatherEntry.TABLE_NAME, null, value);
                    if (_id != -1) {
                        rowsInserted++;
                    }
                }
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }

            if (rowsInserted > 0) {
                getContext().getContentResolver().notifyChange(uri, null);
            }

            return rowsInserted;

        default:
            return super.bulkInsert(uri, values);
    }
}
 
Example 13
Source Project: MediaSDK   File: CacheFileMetadataIndex.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Initializes the index for the given cache UID.
 *
 * <p>This method may be slow and shouldn't normally be called on the main thread.
 *
 * @param uid The cache UID.
 * @throws DatabaseIOException If an error occurs initializing the index.
 */
@WorkerThread
public void initialize(long uid) throws DatabaseIOException {
  try {
    String hexUid = Long.toHexString(uid);
    tableName = getTableName(hexUid);
    SQLiteDatabase readableDatabase = databaseProvider.getReadableDatabase();
    int version =
        VersionTable.getVersion(
            readableDatabase, VersionTable.FEATURE_CACHE_FILE_METADATA, hexUid);
    if (version != TABLE_VERSION) {
      SQLiteDatabase writableDatabase = databaseProvider.getWritableDatabase();
      writableDatabase.beginTransactionNonExclusive();
      try {
        VersionTable.setVersion(
            writableDatabase, VersionTable.FEATURE_CACHE_FILE_METADATA, hexUid, TABLE_VERSION);
        dropTable(writableDatabase, tableName);
        writableDatabase.execSQL("CREATE TABLE " + tableName + " " + TABLE_SCHEMA);
        writableDatabase.setTransactionSuccessful();
      } finally {
        writableDatabase.endTransaction();
      }
    }
  } catch (SQLException e) {
    throw new DatabaseIOException(e);
  }
}
 
Example 14
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    db.beginTransaction();

    doLegacyMigration(db, oldVersion, newVersion);
    doAttachmentMigrationTo47(db, oldVersion, newVersion);
    doSMSMigrationTo49(db, oldVersion, newVersion);
    doRecipientMigrationTo52(db, oldVersion, newVersion);
    doRecipientMigrationTo57(db, oldVersion, newVersion);
    doRecipientMigrationTo58(db, oldVersion, newVersion);

    db.setTransactionSuccessful();
    db.endTransaction();

}
 
Example 15
public void putBulkItemValue(JsonArray api_data) {
    SQLiteDatabase db = null;
    SQLiteStatement statement;
    try {
        if (api_data.size() > 0) {
            db = getWritableDatabase();
            db.delete(slotitem_table_name, null, null);
            db.beginTransaction();
            statement = db.compileStatement("INSERT INTO ".concat(slotitem_table_name).concat(" (KEY, KCID, VALUE) values (?, ?, ?)"));

            for (JsonElement item: api_data) {
                int column = 1;
                JsonObject item_data = item.getAsJsonObject();
                String api_id = item_data.get("api_id").getAsString();
                String api_slotitem_id = item_data.get("api_slotitem_id").getAsString();
                statement.bindString(column++, api_id);
                statement.bindString(column++, api_slotitem_id);
                statement.bindString(column++, item_data.toString());
                statement.execute();
            }
            statement.close();
            db.setTransactionSuccessful();
        }
    } catch (RuntimeException e) {
        e.printStackTrace();
    } finally {
        if (db != null) {
            db.endTransaction();
        }
    }
}
 
Example 16
@Override
public void onUpgrade(final SQLiteDatabase database,
		final ConnectionSource connectionSource, final int oldVersion, final int newVersion) {
	
	
	if (oldVersion < 111) {
		// Create new Caption table.
		try {
			TableUtils.createTableIfNotExists(connectionSource, Caption.class);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	if (oldVersion < 114) {
		// Could instead create an ORMLite pojo for topicvideo and do this with TableUtils.
		database.execSQL("CREATE TABLE IF NOT EXISTS `topicvideo` (`_id` INTEGER PRIMARY KEY AUTOINCREMENT, `topic_id` VARCHAR, `video_id` VARCHAR )");
	}
	
	if (newVersion >= 111) {
		
		// Played with the idea of putting this all into an AsyncTask, but
		//  1) Can crash the app. For example, in 114 upgrade we add topicvideo table; if it doesn't exist and user reaches a video list, we 
		//     crash. Worse, if we do crash here the app is broken. Db version has been bumped, so this code doesn't get another chance to run.
		//  2) To prevent crash, tried showing AlertDialog. The context we get here is "not an application context", so trying to show a window
		//     (or sometimes a toast) crashes us with a null window token error. I dug deep to try to pass in a useful context with no luck.
		//     See branch temp/pass_context_to_helper.
		//  3) It doesn't take very long (truncate / reload full video and topic tables is just a few seconds, not long enough for ANR on Fire HD)
		
		new DatabaseImporter(context).import_(DATABASE_RESOURCE_ID, "temp");
		SQLiteDatabase tempDb = new TempHelper(context).getReadableDatabase();
		
		if (oldVersion < 111) {
			do111Upgrade(database, tempDb);
		}
		
		if (oldVersion < 114 && newVersion >= 114) {
			// add topicvideo table
			do114Upgrade(database, tempDb);
		}
		
		if (oldVersion < 120 && newVersion >= 120) {
			// add video.dlm_id column
			do120Upgrade(database, tempDb);
		}
		
		tempDb.close();
		context.deleteDatabase(TempHelper.DB_NAME);
		
		// Update download status from storage. This recovers any lost during library updates in 1.1.3.
		database.beginTransaction();
		try {
			for (String yid : getAllDownloadedYoutubeIds()) {
				database.execSQL("update video set download_status=? where youtube_id=?", new Object[] {Video.DL_STATUS_COMPLETE, yid});
			}
			database.setTransactionSuccessful();
		} finally {
			database.endTransaction();
		}
				
	}
		
}
 
Example 17
Source Project: Woodmin   File: WoodminProvider.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public int update(Uri uri, ContentValues contentValues, String selection, String[] selectionArgs) {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    final int match = sUriMatcher.match(uri);
    int rowsUpdated;

    switch (match) {
        case SHOP:
            db.beginTransaction();
            try {
                rowsUpdated = db.update(WoodminContract.ShopEntry.TABLE_NAME, contentValues, selection,
                        selectionArgs);
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
            break;
        case ORDER:
            db.beginTransaction();
            try {
                rowsUpdated = db.update(WoodminContract.OrdersEntry.TABLE_NAME, contentValues, selection,
                        selectionArgs);
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
            break;
        case PRODUCT:
            db.beginTransaction();
            try {
                rowsUpdated = db.update(WoodminContract.ProductEntry.TABLE_NAME, contentValues, selection,
                        selectionArgs);
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
            break;
        case CONSUMER:
            db.beginTransaction();
            try {
                rowsUpdated = db.update(WoodminContract.CustomerEntry.TABLE_NAME, contentValues, selection,
                        selectionArgs);
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
            break;
        default:
            throw new UnsupportedOperationException("Unknown uri: " + uri);
    }
    //getContext().getContentResolver().notifyChange(uri, null, false);
    return rowsUpdated;
}
 
Example 18
@Override
public void load(
    HashMap<String, CachedContent> content, SparseArray<@NullableType String> idToKey)
    throws IOException {
  Assertions.checkState(pendingUpdates.size() == 0);
  try {
    int version =
        VersionTable.getVersion(
            databaseProvider.getReadableDatabase(),
            VersionTable.FEATURE_CACHE_CONTENT_METADATA,
            hexUid);
    if (version != TABLE_VERSION) {
      SQLiteDatabase writableDatabase = databaseProvider.getWritableDatabase();
      writableDatabase.beginTransaction();
      try {
        initializeTable(writableDatabase);
        writableDatabase.setTransactionSuccessful();
      } finally {
        writableDatabase.endTransaction();
      }
    }

    try (Cursor cursor = getCursor()) {
      while (cursor.moveToNext()) {
        int id = cursor.getInt(COLUMN_INDEX_ID);
        String key = cursor.getString(COLUMN_INDEX_KEY);
        byte[] metadataBytes = cursor.getBlob(COLUMN_INDEX_METADATA);

        ByteArrayInputStream inputStream = new ByteArrayInputStream(metadataBytes);
        DataInputStream input = new DataInputStream(inputStream);
        DefaultContentMetadata metadata = readContentMetadata(input);

        CachedContent cachedContent = new CachedContent(id, key, metadata);
        content.put(cachedContent.key, cachedContent);
        idToKey.put(cachedContent.id, cachedContent.key);
      }
    }
  } catch (SQLiteException e) {
    content.clear();
    idToKey.clear();
    throw new DatabaseIOException(e);
  }
}
 
Example 19
Source Project: android-job   File: JobStorage.java    License: Apache License 2.0 4 votes vote down vote up
@SuppressWarnings("deprecation")
private void upgradeFrom4To5(SQLiteDatabase db) {
    // remove "persisted" column and rename "isTransient" to "started", add "transient" column for O
    try {
        db.beginTransaction();

        String newTable = JOB_TABLE_NAME + "_new";

        db.execSQL("create table " + newTable + " ("
                + COLUMN_ID + " integer primary key, "
                + COLUMN_TAG + " text not null, "
                + COLUMN_START_MS + " integer, "
                + COLUMN_END_MS + " integer, "
                + COLUMN_BACKOFF_MS + " integer, "
                + COLUMN_BACKOFF_POLICY + " text not null, "
                + COLUMN_INTERVAL_MS + " integer, "
                + COLUMN_REQUIREMENTS_ENFORCED + " integer, "
                + COLUMN_REQUIRES_CHARGING + " integer, "
                + COLUMN_REQUIRES_DEVICE_IDLE + " integer, "
                + COLUMN_EXACT + " integer, "
                + COLUMN_NETWORK_TYPE + " text not null, "
                + COLUMN_EXTRAS + " text, "
                + COLUMN_NUM_FAILURES + " integer, "
                + COLUMN_SCHEDULED_AT + " integer, "
                + COLUMN_STARTED + " integer, "
                + COLUMN_FLEX_MS + " integer, "
                + COLUMN_FLEX_SUPPORT + " integer, "
                + COLUMN_LAST_RUN + " integer);");

        db.execSQL("INSERT INTO " + newTable + " SELECT "
                + COLUMN_ID + ","
                + COLUMN_TAG + ","
                + COLUMN_START_MS + ","
                + COLUMN_END_MS + ","
                + COLUMN_BACKOFF_MS + ","
                + COLUMN_BACKOFF_POLICY + ","
                + COLUMN_INTERVAL_MS + ","
                + COLUMN_REQUIREMENTS_ENFORCED + ","
                + COLUMN_REQUIRES_CHARGING + ","
                + COLUMN_REQUIRES_DEVICE_IDLE + ","
                + COLUMN_EXACT + ","
                + COLUMN_NETWORK_TYPE + ","
                + COLUMN_EXTRAS + ","
                + COLUMN_NUM_FAILURES + ","
                + COLUMN_SCHEDULED_AT + ","
                + COLUMN_TRANSIENT_OLD + ","
                + COLUMN_FLEX_MS + ","
                + COLUMN_FLEX_SUPPORT + ","
                + COLUMN_LAST_RUN + " FROM " + JOB_TABLE_NAME);

        db.execSQL("DROP TABLE " + JOB_TABLE_NAME);
        db.execSQL("ALTER TABLE " + newTable + " RENAME TO " + JOB_TABLE_NAME);

        db.execSQL("alter table " + JOB_TABLE_NAME + " add column " + COLUMN_TRANSIENT + " integer;");

        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
}
 
Example 20
/**
 * Ordinarily, if a column is no longer used, we'd err on the side of just leaving it in the
 * database but stop referring to it in Java. However because it forms part of the primary
 * key of this table, we need to change the primary key to something which _is_ used. Thus,
 * this function will rename the old table, create the new table, and then insert all of the
 * data from the old into the new with the new primary key.
 */
private void removeApkPackageNameColumn(SQLiteDatabase db, int oldVersion) {
    if (oldVersion < 59) {

        Utils.debugLog(TAG, "Changing primary key of " + ApkTable.NAME + " from package + vercode to app + vercode + repo");
        db.beginTransaction();

        try {
            // http://stackoverflow.com/questions/805363/how-do-i-rename-a-column-in-a-sqlite-database-table#805508
            String tempTableName = ApkTable.NAME + "__temp__";
            db.execSQL("ALTER TABLE " + ApkTable.NAME + " RENAME TO " + tempTableName + ";");

            String createTableDdl = "CREATE TABLE " + ApkTable.NAME + " ( "
                    + ApkTable.Cols.APP_ID + " integer not null, "
                    + ApkTable.Cols.VERSION_NAME + " text not null, "
                    + ApkTable.Cols.REPO_ID + " integer not null, "
                    + ApkTable.Cols.HASH + " text not null, "
                    + ApkTable.Cols.VERSION_CODE + " int not null,"
                    + ApkTable.Cols.NAME + " text not null, "
                    + ApkTable.Cols.SIZE + " int not null, "
                    + ApkTable.Cols.SIGNATURE + " string, "
                    + ApkTable.Cols.SOURCE_NAME + " string, "
                    + ApkTable.Cols.MIN_SDK_VERSION + " integer, "
                    + ApkTable.Cols.TARGET_SDK_VERSION + " integer, "
                    + ApkTable.Cols.MAX_SDK_VERSION + " integer, "
                    + ApkTable.Cols.REQUESTED_PERMISSIONS + " string, "
                    + ApkTable.Cols.FEATURES + " string, "
                    + ApkTable.Cols.NATIVE_CODE + " string, "
                    + ApkTable.Cols.HASH_TYPE + " string, "
                    + ApkTable.Cols.ADDED_DATE + " string, "
                    + ApkTable.Cols.IS_COMPATIBLE + " int not null, "
                    + ApkTable.Cols.INCOMPATIBLE_REASONS + " text, "
                    + "PRIMARY KEY (" + ApkTable.Cols.APP_ID + ", " + ApkTable.Cols.VERSION_CODE + ", " + ApkTable.Cols.REPO_ID + ")"
                    + ");";

            db.execSQL(createTableDdl);

            String nonPackageNameFields = TextUtils.join(", ", new String[]{
                    ApkTable.Cols.APP_ID,
                    ApkTable.Cols.VERSION_NAME,
                    ApkTable.Cols.REPO_ID,
                    ApkTable.Cols.HASH,
                    ApkTable.Cols.VERSION_CODE,
                    ApkTable.Cols.NAME,
                    ApkTable.Cols.SIZE,
                    ApkTable.Cols.SIGNATURE,
                    ApkTable.Cols.SOURCE_NAME,
                    ApkTable.Cols.MIN_SDK_VERSION,
                    ApkTable.Cols.TARGET_SDK_VERSION,
                    ApkTable.Cols.MAX_SDK_VERSION,
                    ApkTable.Cols.REQUESTED_PERMISSIONS,
                    ApkTable.Cols.FEATURES,
                    ApkTable.Cols.NATIVE_CODE,
                    ApkTable.Cols.HASH_TYPE,
                    ApkTable.Cols.ADDED_DATE,
                    ApkTable.Cols.IS_COMPATIBLE,
                    ApkTable.Cols.INCOMPATIBLE_REASONS,
            });

            String insertSql = "INSERT INTO " + ApkTable.NAME +
                    "(" + nonPackageNameFields + " ) " +
                    "SELECT " + nonPackageNameFields + " FROM " + tempTableName + ";";

            db.execSQL(insertSql);
            db.execSQL("DROP TABLE " + tempTableName + ";");

            // Now that the old table has been dropped, we can create indexes again.
            // Attempting this before dropping the old table will not work, because the
            // indexes exist on the _old_ table, and so are unable to be added (with the
            // same name) to the _new_ table.
            ensureIndexes(db);

            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
    }
}