下面列出了android.database.sqlite.SQLiteDatabase#insertOrThrow ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* 增加到缓存列表中
*
* @param url
* @return
*/
public boolean add(String url) {
if (isCached(url)) {
return false;
}
SQLiteDatabase db = new DatabaseOpenHelper(context).getWritableDatabase();
try {
ContentValues contentValues = new ContentValues();
contentValues.put(COLUM_URL, url);
long values = db.insertOrThrow(DATABASE_THUMBNAILS_TABLE_NAME, null, contentValues);
return values > 1;
} catch (SQLiteException e) {
return false;
} finally {
db.close();
}
}
public int addCollection(ContentValues contentValues) {
// Create and/or open the database for writing
SQLiteDatabase db = getWritableDatabase();
// It's a good idea to wrap our insert in a transaction. This helps with performance and ensures
// consistency of the database.
db.beginTransaction();
try {
db.insertOrThrow(PredatorContract.CollectionsEntry.TABLE_NAME, null, contentValues);
db.setTransactionSuccessful();
} catch (Exception e) {
Logger.e(TAG, "Error while trying to add collection to database", e);
} finally {
db.endTransaction();
}
return contentValues.getAsInteger(PredatorContract.CollectionsEntry.COLUMN_COLLECTION_ID);
}
public void addContact(String name, String uri) throws SQLException
{
if (databaseHelper == null) {
throw new RuntimeException("Database hasn't been opened.");
}
// Gets the data repository in write mode
SQLiteDatabase db = databaseHelper.getWritableDatabase();
// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
values.put(DatabaseContract.ContactEntry.COLUMN_NAME_NAME, name);
values.put(DatabaseContract.ContactEntry.COLUMN_NAME_URI, uri);
db.insertOrThrow(DatabaseContract.ContactEntry.TABLE_NAME, null, values);
}
@Override
public Uri insert(Uri uri, ContentValues values) {
final int match = sUriMatcher.match(uri);
SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
switch (match) {
case ENTRIES: {
db.insertOrThrow(Tables.ENTRIES, null, values);
notifyChange(uri);
return Entries.buildEntryUri(values.getAsString(Entries.UUID));
}
default: {
throw new UnsupportedOperationException("Unknown insert uri: " + uri);
}
}
}
/**
* Add a note without transaction (for fast insert of many).
*
* @param lon lon
* @param lat lat
* @param altim elevation
* @param timestamp the UTC timestamp in millis.
* @param text the text
* @param description a description.
* @param form the json form or null
* @param sqliteDatabase the database reference.
* @return the inserted note id.
*/
public static long addNoteNoTransaction(double lon, double lat, double altim, long timestamp, String text,
String description, String form, String style, SQLiteDatabase sqliteDatabase) {
ContentValues values = new ContentValues();
values.put(NotesTableFields.COLUMN_LON.getFieldName(), lon);
values.put(NotesTableFields.COLUMN_LAT.getFieldName(), lat);
values.put(NotesTableFields.COLUMN_ALTIM.getFieldName(), altim);
values.put(NotesTableFields.COLUMN_TS.getFieldName(), timestamp);
if (description != null)
values.put(NotesTableFields.COLUMN_DESCRIPTION.getFieldName(), description);
values.put(NotesTableFields.COLUMN_TEXT.getFieldName(), text);
if (form != null)
values.put(NotesTableFields.COLUMN_FORM.getFieldName(), form);
if (style != null)
values.put(NotesTableFields.COLUMN_STYLE.getFieldName(), style);
values.put(NotesTableFields.COLUMN_ISDIRTY.getFieldName(), 1);
long noteId = sqliteDatabase.insertOrThrow(TABLE_NOTES, null, values);
return noteId;
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE " + EarthsContract.TABLE +
" (" + EarthsContract.Columns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT" +
", " + EarthsContract.Columns.FILE + " TEXT" +
", " + EarthsContract.Columns.FETCHED_AT + " INTEGER" +
")");
@SuppressWarnings("ConstantConditions") final LegacyEarthSharedState state
= new LegacyEarthSharedState(getContext());
if (!TextUtils.isEmpty(state.getLastEarth())) {
ContentValues values = new ContentValues();
values.put(EarthsContract.Columns.FILE, state.getLastEarth());
values.put(EarthsContract.Columns.FETCHED_AT, System.currentTimeMillis());
db.insertOrThrow(EarthsContract.TABLE, null, values);
}
}
private static void saveTabInfo(SQLiteDatabase db, Themes topics, String template) {
ContentValues values = new ContentValues();
values.put(COLUMN_ID, -1);
values.put(COLUMN_TEMPLATE, template);
values.put(COLUMN_MAXCOUNT, topics.getThemesCount());
db.insertOrThrow(TABLE_NAME, null, values);
}
@Override
public int bulkInsert(@NonNull Uri uri, @NonNull ContentValues[] values) {
if (values.length == 0) return 0;
TableDetails tableDetails = mUriMatcherHelper.getTableDetails(uri);
SQLiteDatabase db = mDatabase.getWritableDatabase();
if (mDebugEnabled) {
QuantumFluxLog.d("********* Bulk Insert **********");
QuantumFluxLog.d("Uri: " + uri);
}
int count = 0;
try {
db.beginTransactionNonExclusive();
String tableName = tableDetails.getTableName();
for (ContentValues value : values) {
db.insertOrThrow(tableName, null, value);
count++;
}
db.setTransactionSuccessful();
notifyChanges(uri, tableDetails);
} finally {
db.endTransaction();
}
return count;
}
public static void addRealtion(CharSequence packName, CharSequence topicId) {
SQLiteDatabase db = null;
try {
DbHelper dbHelper = new DbHelper(App.getInstance());
db = dbHelper.getWritableDatabase();
String[] selectionArgs = new String[]{packName + "%"};
db.execSQL("delete from " + TABLE_NAME + " where pack_name like ?", selectionArgs);
ContentValues values = new ContentValues();
values.put(COLUMN_ID, UUID.randomUUID().toString());
values.put(COLUMN_PACK_NAME, packName.toString());
values.put(COLUMN_APP_URL, topicId.toString());
values.put(COLUMN_BYUSER_NAME, true);
db.insertOrThrow(TABLE_NAME, null, values);
} catch (Exception ex) {
AppLog.e(App.getInstance(), ex);
} finally {
if (db != null) {
// db.endTransaction();
db.close();
}
}
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE " + SettingsContract.TABLE +
" (" + SettingsContract.Columns.INTERVAL + " INTEGER" +
", " + SettingsContract.Columns.RESOLUTION + " INTEGER" +
", " + SettingsContract.Columns.WIFI_ONLY + " INTEGER" +
", " + SettingsContract.Columns.DEBUG + " INTEGER" +
", " + SettingsContract.Columns.OFFSET_L + " REAL" +
", " + SettingsContract.Columns.OFFSET_S + " REAL" +
", " + SettingsContract.Columns.SCALE + " REAL DEFAULT 1" +
")");
db.insertOrThrow(SettingsContract.TABLE, null,
Settings.fromLegacySharedState(getContext()).toContentValues());
}
@Override
public Uri insert(@NonNull Uri uri, ContentValues values) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
switch (match) {
case VIDEOITEM: {
final long _id = db.insertOrThrow(Tables.VIDEO_ITEM, null, values);
return VideoItemContract.VideoItem.buildItemUri(_id);
}
default: {
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
}
/**
* @param url URL to the root of the used Nextcloud instance without trailing slash
* @param username Username of the account
* @param accountName Composed by the username and the host of the URL, separated by @-sign
* @param capabilities {@link Capabilities} object containing information about the brand colors, supported API versions, etc...
* @throws SQLiteConstraintException in case accountName already exists
*/
public void addAccount(@NonNull String url, @NonNull String username, @NonNull String accountName, @NonNull Capabilities capabilities) throws SQLiteConstraintException {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues(4);
values.put(key_url, url);
values.put(key_username, username);
values.put(key_account_name, accountName);
values.put(key_capabilities_etag, capabilities.getETag());
long accountId = db.insertOrThrow(table_accounts, null, values);
updateBrand(accountId, capabilities);
}
/**
* Registra una ubicación en la Base de Datos
*/
public void nuevaUbicacion(Ubicacion ubicacion) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues valores = new ContentValues();
valores.put(NOMBRE, ubicacion.getNombre());
valores.put(LATITUD, ubicacion.getPosicion().latitude);
valores.put(LONGITUD, ubicacion.getPosicion().longitude);
db.insertOrThrow(TABLA, null, valores);
}
@Override
public int bulkInsert(@NonNull Uri uri, @NonNull ContentValues[] values) {
int length = values.length;
if (length == 0)
return 0;
TableDetails tableDetails = uriMatcherHelper.getTableDetails(uri);
SQLiteDatabase db = database.getWritableDatabase();
if (debugEnabled) {
CPOrmLog.d("********* Bulk Insert **********");
CPOrmLog.d("Uri: " + uri);
}
int count = 0;
try {
db.beginTransactionNonExclusive();
String tableName = tableDetails.getTableName();
for (int i = 0; i < length; i++) {
db.insertOrThrow(tableName, null, values[i]);
count++;
if (count % 100 == 0)
db.yieldIfContendedSafely();
}
db.setTransactionSuccessful();
notifyChanges(uri.buildUpon().appendQueryParameter(PARAMETER_CHANGE_TYPE, CPOrm.ChangeType.INSERT.toString()).build(), tableDetails);
} finally {
db.endTransaction();
}
return count;
}
public void addMessage(String contactName, String messageText, boolean isLocal, String jobId, DatabaseContract.MessageDeliveryStatus deliveryStatus) throws SQLException
{
if (databaseHelper == null) {
throw new RuntimeException("Database hasn't been opened.");
}
// Gets the data repository in write mode
SQLiteDatabase db = databaseHelper.getWritableDatabase();
// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
String type = "local";
if (!isLocal) {
type = "remote";
}
int contactId = getContactIdFromName(contactName);
values.put(DatabaseContract.MessageEntry.COLUMN_NAME_CONTACT_ID, contactId);
values.put(DatabaseContract.MessageEntry.COLUMN_NAME_TEXT, messageText);
values.put(DatabaseContract.MessageEntry.COLUMN_NAME_TYPE, type);
values.put(DatabaseContract.MessageEntry.COLUMN_NAME_JOB_ID, jobId);
values.put(DatabaseContract.MessageEntry.COLUMN_NAME_DELIVERY_STATUS, deliveryStatus.ordinal());
db.insertOrThrow(DatabaseContract.MessageEntry.TABLE_NAME, null, values);
}
public long insert(String entityName, T data)
{
SQLiteDatabase database = helper.getWritableDatabase();
ContentValues values = new ContentValues(2);
values.put("Name", entityName);
values.put("Data", Serializer.Serialize(data));
return database.insertOrThrow(name, null, values);
}
@Override
public Uri insert(@NonNull Uri uri, ContentValues values) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
switch (match) {
case ITEMS: {
final long _id = db.insertOrThrow(Tables.ITEMS, null, values);
mContext.getContentResolver().notifyChange(uri, null);
return ItemsContract.Items.buildItemUri(_id);
}
default: {
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
}
/**
* Recreates workspace table and migrates data to the new table.
*/
boolean recreateWorkspaceTable(SQLiteDatabase db) {
db.beginTransaction();
try {
Cursor c = db.query(WorkspaceScreens.TABLE_NAME,
new String[] {LauncherSettings.WorkspaceScreens._ID},
null, null, null, null,
LauncherSettings.WorkspaceScreens.SCREEN_RANK);
ArrayList<Long> sortedIDs = new ArrayList<Long>();
long maxId = 0;
try {
while (c.moveToNext()) {
Long id = c.getLong(0);
if (!sortedIDs.contains(id)) {
sortedIDs.add(id);
maxId = Math.max(maxId, id);
}
}
} finally {
c.close();
}
db.execSQL("DROP TABLE IF EXISTS " + WorkspaceScreens.TABLE_NAME);
addWorkspacesTable(db, false);
// Add all screen ids back
int total = sortedIDs.size();
for (int i = 0; i < total; i++) {
ContentValues values = new ContentValues();
values.put(LauncherSettings.WorkspaceScreens._ID, sortedIDs.get(i));
values.put(LauncherSettings.WorkspaceScreens.SCREEN_RANK, i);
addModifiedTime(values);
db.insertOrThrow(WorkspaceScreens.TABLE_NAME, null, values);
}
db.setTransactionSuccessful();
mMaxScreenId = maxId;
} catch (SQLException ex) {
// Old version remains, which means we wipe old data
ex.printStackTrace();
return false;
} finally {
db.endTransaction();
}
return true;
}
/**
* Recreates workspace table and migrates data to the new table.
*/
public boolean recreateWorkspaceTable(SQLiteDatabase db) {
db.beginTransaction();
try {
Cursor c = db.query(TABLE_WORKSPACE_SCREENS,
new String[] {LauncherSettings.WorkspaceScreens._ID},
null, null, null, null,
LauncherSettings.WorkspaceScreens.SCREEN_RANK);
ArrayList<Long> sortedIDs = new ArrayList<Long>();
long maxId = 0;
try {
while (c.moveToNext()) {
Long id = c.getLong(0);
if (!sortedIDs.contains(id)) {
sortedIDs.add(id);
maxId = Math.max(maxId, id);
}
}
} finally {
c.close();
}
db.execSQL("DROP TABLE IF EXISTS " + TABLE_WORKSPACE_SCREENS);
addWorkspacesTable(db);
// Add all screen ids back
int total = sortedIDs.size();
for (int i = 0; i < total; i++) {
ContentValues values = new ContentValues();
values.put(LauncherSettings.WorkspaceScreens._ID, sortedIDs.get(i));
values.put(LauncherSettings.WorkspaceScreens.SCREEN_RANK, i);
addModifiedTime(values);
db.insertOrThrow(TABLE_WORKSPACE_SCREENS, null, values);
}
db.setTransactionSuccessful();
mMaxScreenId = maxId;
} catch (SQLException ex) {
// Old version remains, which means we wipe old data
Log.e(TAG, ex.getMessage(), ex);
return false;
} finally {
db.endTransaction();
}
return true;
}
public synchronized void put(E object) {
final SQLiteDatabase db = getWritableDatabase();
try {
final ContentValues values = new ContentValues(fields.length + 1);
final long result = db.insertOrThrow(TABLE_NAME, null, toContentValues(object, values));
if(result < 0) throw new RuntimeException("Database write failed");
} catch(IllegalAccessException e) {
throw new RuntimeException(e);
} finally { db.close(); }
}