@Test(expected = SQLException.class) //Handle this better? public void query_forMessagesWithAccountAndRequiredFieldsWithNoOrderBy_throwsSQLiteException() { Account account = Preferences.getPreferences(getContext()).newAccount(); account.getUuid(); Cursor cursor = getProvider().query( Uri.parse("content://" + EmailProvider.AUTHORITY + "/account/" + account.getUuid() + "/messages"), new String[] { EmailProvider.MessageColumns.ID, EmailProvider.MessageColumns.FOLDER_ID, EmailProvider.ThreadColumns.ROOT }, "", new String[] {}, ""); assertNotNull(cursor); assertTrue(cursor.isAfterLast()); }
@Test public void executeInsertThrowsAndDoesNotTrigger() { SQLiteStatement statement = real.compileStatement("INSERT INTO " + TABLE_EMPLOYEE + " (" + NAME + ", " + USERNAME + ") " + "VALUES ('Alice Allison', 'alice')"); db.createQuery(TABLE_EMPLOYEE, SELECT_EMPLOYEES) .skip(1) // Skip initial .subscribe(o); try { db.executeInsert(TABLE_EMPLOYEE, statement); fail(); } catch (SQLException ignored) { } o.assertNoMoreEvents(); }
/** * Should try to use the legacy parser by default, which is be unable to handle the SQL script. */ public void testLegacyMigration() { try { Configuration configuration = new Configuration.Builder(getContext()) .setDatabaseName("migration.db") .setDatabaseVersion(2) .create(); DatabaseHelper helper = new DatabaseHelper(configuration); SQLiteDatabase db = helper.getWritableDatabase(); helper.onUpgrade(db, 1, 2); fail("Should not be able to parse the SQL script."); } catch (SQLException e) { final String message = e.getMessage(); assertNotNull(message); assertTrue(message.contains("syntax error")); assertTrue(message.contains("near \"MockMigration\"")); } }
public boolean Update(@NonNull LucaMenu updateEntry) throws SQLException { ContentValues contentValues = new ContentValues(); contentValues.put(KEY_ROW_ID, updateEntry.GetId()); contentValues.put(KEY_WEEKDAY, updateEntry.GetWeekday().GetEnglishDay()); contentValues.put(KEY_DAY, String.valueOf(updateEntry.GetDate().DayOfMonth())); contentValues.put(KEY_MONTH, String.valueOf(updateEntry.GetDate().Month())); contentValues.put(KEY_YEAR, String.valueOf(updateEntry.GetDate().Year())); contentValues.put(KEY_TITLE, updateEntry.GetTitle()); contentValues.put(KEY_DESCRIPTION, updateEntry.GetDescription()); contentValues.put(KEY_IS_ON_SERVER, String.valueOf(updateEntry.GetIsOnServer())); contentValues.put(KEY_SERVER_ACTION, updateEntry.GetServerDbAction().toString()); _database.update(DATABASE_TABLE, contentValues, KEY_ROW_ID + "=" + updateEntry.GetId(), null); return true; }
public user getItm(int uid) throws SQLException { Cursor cursor = this.db.query(true, DATABASE_MAINTABLE, this.yek_SH_flashkart, "uid == '" + uid + "' ", null, null, null, null, null); user nam = new user(); if (cursor != null) { cursor.moveToFirst(); nam.setId(cursor.getInt(cursor.getColumnIndex(KEY_ID))); nam.setUid(cursor.getInt(cursor.getColumnIndex(KEY_UID))); nam.setFname(cursor.getString(cursor.getColumnIndex(KEY_FNAME))); nam.setLname(cursor.getString(cursor.getColumnIndex(KEY_LNAME))); nam.setUsername(cursor.getString(cursor.getColumnIndex(KEY_USERNAME))); nam.setPic(cursor.getString(cursor.getColumnIndex(KEY_PIC))); nam.setStatus(cursor.getString(cursor.getColumnIndex(KEY_STATUS))); nam.setPhone(cursor.getString(cursor.getColumnIndex(KEY_PHONE))); nam.setUptime(cursor.getString(cursor.getColumnIndex(KEY_UPTIME))); nam.setIsupdate(cursor.getInt(cursor.getColumnIndex(KEY_ISUPDATE))); nam.setIsspecific(cursor.getInt(cursor.getColumnIndex(KEY_ISSPECEFIC))); nam.setPicup(cursor.getInt(cursor.getColumnIndex(KEY_PICUP))); nam.setStatusup(cursor.getInt(cursor.getColumnIndex(KEY_STATUSUP))); nam.setPhoneup(cursor.getInt(cursor.getColumnIndex(KEY_PHONEUP))); nam.setIsonetime(cursor.getInt(cursor.getColumnIndex(KEY_ISONETIME))); } assert cursor != null; cursor.close(); return nam; }
@Nullable @Override public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) { SQLiteDatabase db = sqlHelper.getReadableDatabase(); int uriRequest = uriMatcher.match(uri); Uri insertUri; long insertid; if (uriRequest == ContentContract.TASK){ insertid = db.insert(ContentContract.TABLE, null, contentValues); if (insertid > 0){ insertUri = ContentUris.withAppendedId(ContentContract.CONTENT_URI, insertid); } else { throw new SQLException("Failed to insert row into " + uri.getPath()); } } else { throw new UnsupportedOperationException("unknown uri"); } getContext().getContentResolver().notifyChange(uri, null); return insertUri; }
public hideObjc getItm(int ID) throws SQLException { Cursor cursor = this.db.query(true, DATABASE_MAINTABLE, this.yek_SH_flashkart, "dialog_id == '" + ID + "' AND isHidden = 1", null, null, null, null, null); hideObjc nam = new hideObjc(); if (cursor != null && cursor.getCount() > 0) { cursor.moveToFirst(); nam.setId(cursor.getInt(cursor.getColumnIndex(KEY_ID))); nam.setDialog_id(cursor.getInt(cursor.getColumnIndex(KEY_DIALOG_ID))); nam.setHideCode(cursor.getInt(cursor.getColumnIndex(KEY_HIDE_CODE))); nam.setIsChannel(cursor.getInt(cursor.getColumnIndex(KEY_IS_CHANNEL))); nam.setIsGroup(cursor.getInt(cursor.getColumnIndex(KEY_IS_GROUP))); nam.setIsHidden(cursor.getInt(cursor.getColumnIndex(KEY_IS_HIDDEN))); } assert cursor != null; cursor.close(); return nam; }
private void beginTransaction(SQLiteTransactionListener transactionListener, boolean exclusive) { acquireReference(); try { // getThreadSession().beginTransaction( // exclusive ? ShadowSQLiteSession.TRANSACTION_MODE_EXCLUSIVE : // ShadowSQLiteSession.TRANSACTION_MODE_IMMEDIATE, // transactionListener, // getThreadDefaultConnectionFlags(false /*readOnly*/), null); isTransaction = true; mConnection.setAutoCommit(false); } catch (java.sql.SQLException e) { e.printStackTrace(); } finally { releaseReference(); } }
@Nullable @Override public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) { int match = sUriMatcher.match(uri); Uri returnUri; switch (match) { case RECIPES: Recipe recipe = buildRecipeFromContentValues(contentValues); long recipeId = recipeDao.insertRecipe(recipe); if (recipeId > 0){ returnUri = ContentUris.withAppendedId(RecipesContract.RecipeEntry.CONTENT_URI, recipeId); } else { throw new SQLException("Failed to insert row into " + uri); } break; default: throw new UnsupportedOperationException("Unknown uri: " + uri); } mContext.getContentResolver().notifyChange(uri, null); return returnUri; }
@Override public void onClick(View view) { try { // update this group to database .... ArticlesDataSource mDbHelper = new ArticlesDataSource(getApplicationContext()); mDbHelper.createDatabase(); mDbHelper.open(); long updatedId = mDbHelper.updateGroup(groupName, listOfIdsLessons, getIdGroupToBeUpdated()); if (updatedId != -1) { //Toast.makeText(getApplicationContext(), R.string.group_has_been_saved, Toast.LENGTH_SHORT).show(); // ... and go to activity to show it Intent intent = new Intent(getApplicationContext(), AllArticlesListViewActivity.class); intent.putExtra("group_id", getIdGroupToBeUpdated()); intent.putExtra("group_name", groupName); intent.putExtra("status_what_show", ActivityArticlesStatusToShow.SHOW_ALL_GROUPS); startActivity(intent); } else { // throw exception } } catch (SQLException e) { e.printStackTrace(); } }
/** * We have to options to find articles: * 1. Find all articles - in this case we have ids as null * 2. Find articles inside group - in this case we must to pass ids of group. In activity we have getIdsOfGroup() to do this. * * @param articleName name of article * @param ids sequence of ids of article where we need to search * @return Cursor */ public Cursor findArticles(String articleName, String ids) { try { String sql; if (ids == null) { sql = "select _id as _id, unit_number as title, html as html from articles \n" + "where unit_number like '%" + articleName + "%' order by _id "; } else { sql = "select _id as _id, unit_number as title, html as html from articles \n" + "where unit_number like '%" + articleName + "%' and _id in (" + ids + ") order by _id "; } Cursor mCur = mDb.rawQuery(sql, null); if (mCur != null) { mCur.moveToNext(); } return mCur; } catch (SQLException mSQLException) { throw mSQLException; } }
public boolean Update(@NonNull ShoppingEntry updateEntry) throws SQLException { ContentValues contentValues = new ContentValues(); contentValues.put(KEY_ROW_ID, updateEntry.GetId()); contentValues.put(KEY_NAME, updateEntry.GetName()); contentValues.put(KEY_GROUP, updateEntry.GetGroup().toString()); contentValues.put(KEY_QUANTITY, updateEntry.GetQuantity()); contentValues.put(KEY_UNIT, updateEntry.GetUnit()); contentValues.put(KEY_BOUGHT, (updateEntry.GetBought() ? "1" : "0")); contentValues.put(KEY_IS_ON_SERVER, String.valueOf(updateEntry.GetIsOnServer())); contentValues.put(KEY_SERVER_ACTION, updateEntry.GetServerDbAction().toString()); _database.update(DATABASE_TABLE, contentValues, KEY_ROW_ID + "=" + updateEntry.GetId(), null); return true; }
@Override public void onCreate(SQLiteDatabase sqLiteDatabase) { try { String sql = "CREATE TABLE " + TABLE_NAME + "(" + COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_LEVEL + " INTEGER, " + COLUMN_CONTENT + " VARCHAR, " + COLUMN_DATE + " INTEGER);"; sqLiteDatabase.execSQL(sql); } catch (SQLException ex) { Log.d("PTSqliteHelper", ex.getMessage()); return; } }
private void upgradeDbTo310(SQLiteDatabase db, int oldVersion) throws SQLException { String updSql; if (!columnExists(db, TABLE_NAME_REFUEL, COL_NAME_REFUEL__AMOUNT)) { updSql = "ALTER TABLE " + TABLE_NAME_REFUEL + " ADD " + COL_NAME_REFUEL__AMOUNT + " NUMERIC NULL "; db.execSQL(updSql); updSql = "UPDATE " + TABLE_NAME_REFUEL + " SET " + COL_NAME_REFUEL__AMOUNT + " = " + COL_NAME_REFUEL__QUANTITYENTERED + " * " + COL_NAME_REFUEL__PRICE; db.execSQL(updSql); } if (!columnExists(db, TABLE_NAME_REFUEL, COL_NAME_REFUEL__AMOUNTENTERED)) { updSql = "ALTER TABLE " + TABLE_NAME_REFUEL + " ADD " + COL_NAME_REFUEL__AMOUNTENTERED + " NUMERIC NULL "; db.execSQL(updSql); updSql = "UPDATE " + TABLE_NAME_REFUEL + " SET " + COL_NAME_REFUEL__AMOUNTENTERED + " = " + COL_NAME_REFUEL__QUANTITYENTERED + " * " + COL_NAME_REFUEL__PRICEENTERED; db.execSQL(updSql); } upgradeDbTo330(db, oldVersion); }
public boolean deleteConversation(Conversation conversation) { boolean success; try { this.database.beginTransaction(); if (this.database.delete(InboxSQLiteHelper.TABLE_MESSAGES, "_sender_user_id=" + conversation.getSender().getId(), null) == 0) { throw new SQLException("Failed to delete message from DB"); } else if (this.database.delete(InboxSQLiteHelper.TABLE_CONVERSATIONS, "_sender_user_id=" + conversation.getSender().getId(), null) != 1) { throw new SQLException("Failed to delete message from DB"); } else { this.database.setTransactionSuccessful(); success = true; return success; } } catch (SQLException e) { Log.d(TAG, "Error trying to delete a message"); success = false; } finally { this.database.endTransaction(); } return success; }
public Cursor getInfoFromElemTable(String[] strQuery, String strTableName) { if(strQuery==null) return null; try { StringBuilder tempStrBuilder = new StringBuilder(); tempStrBuilder.append("SELECT "); for(int i=0; i<strQuery.length-1; i++){ tempStrBuilder.append(strQuery[i]); tempStrBuilder.append(", "); } tempStrBuilder.append(strQuery[strQuery.length-1]); tempStrBuilder.append(" FROM "); //tempStrBuilder.append("SELECT energy FROM "); tempStrBuilder.append(strTableName); String sql =tempStrBuilder.toString(); Cursor mCur = mDb.rawQuery(sql, null); return mCur; } catch (SQLException mSQLException) { Log.e(TAG, "getTestData >>"+ mSQLException.toString()); throw mSQLException; } }
private int getProperty(@NonNull String column) { int value = 1; if (!validDatabase()) { return value; } Cursor cursor = null; try { cursor = database.query(PROPERTIES_TABLE, new String[]{ COL_VALUE }, COL_PROPERTY + "= ?", new String[]{ column }, null, null, null); if (cursor != null && cursor.moveToFirst()) { value = cursor.getInt(0); } return value; } catch (SQLException se) { return value; } finally { DatabaseUtils.closeCursor(cursor); } }
/** * Return a Cursor positioned at the record that matches the given rowId * from the given table * * @param rowId id of the record to retrieve * @return Cursor positioned to matching record, if found. Otherwise null. * @throws SQLException if the record could not be found/retrieved */ @Nullable public Cursor fetchRecord(String tableName, String[] columns, long rowId) throws SQLException { Cursor mCursor = mDb.query(true, tableName, columns, COL_NAME_GEN_ROWID + "=" + rowId, null, null, null, null, null); if (mCursor != null) { if (mCursor.moveToFirst()) { return mCursor; } else { mCursor.close(); return null; } } else { return null; } }
@Nullable @Override public Uri insert(Uri uri, ContentValues values) { final SQLiteDatabase db = mCardsDBHelper.getWritableDatabase(); Uri returnUri = null; int match = sUriMatcher.match(uri); switch (match) { case TRANSACTIONS: // Since insert and query all has same url long transactionId = db.insert(DatabaseContract.TABLE_TRANSACTIONS, null, values); if (transactionId > 0) { returnUri = ContentUris.withAppendedId(DatabaseContract.CONTENT_URI, transactionId); getContext().getContentResolver().notifyChange(uri, null); } else { throw new SQLException("Can't create ID"); } break; default: throw new UnsupportedOperationException("This URI is not supported"); } return returnUri; }
public Cursor getElementName(int nInputAtomNum) { try { StringBuilder tempStrBuilder = new StringBuilder(); tempStrBuilder.append(nInputAtomNum); String sql ="SELECT name, density FROM elements WHERE atom_number LIKE " + tempStrBuilder.toString(); Cursor mCur = mDb.rawQuery(sql, null); return mCur; } catch (SQLException mSQLException) { Log.e(TAG, "getTestData >>"+ mSQLException.toString()); throw mSQLException; } }
public boolean Update(@NonNull MoneyMeterData updateEntry) throws SQLException { ContentValues contentValues = new ContentValues(); contentValues.put(KEY_ROW_ID, updateEntry.GetId()); contentValues.put(KEY_TYPE_ID, String.valueOf(updateEntry.GetTypeId())); contentValues.put(KEY_BANK, updateEntry.GetBank()); contentValues.put(KEY_PLAN, updateEntry.GetPlan()); contentValues.put(KEY_AMOUNT, String.valueOf(updateEntry.GetAmount())); contentValues.put(KEY_UNIT, updateEntry.GetUnit()); contentValues.put(KEY_SAVE_DATE, updateEntry.GetSaveDate().toString()); contentValues.put(KEY_USER, updateEntry.GetUser()); _database.update(DATABASE_TABLE, contentValues, KEY_ROW_ID + "=" + updateEntry.GetId(), null); return true; }
private int executeSql(String sql, Object[] bindArgs) throws SQLException { acquireReference(); try { if (ShadowDatabaseUtils.getSqlStatementType(sql) == ShadowDatabaseUtils.STATEMENT_ATTACH) { boolean disableWal = false; synchronized (mLock) { if (!mHasAttachedDbsLocked) { mHasAttachedDbsLocked = true; disableWal = true; } } if (disableWal) { disableWriteAheadLogging(); } } ShadowSQLiteStatement statement = new ShadowSQLiteStatement(this, sql, bindArgs); try { // PRAGMA user_version = x if (sql.startsWith("PRAGMA") && sql.contains("=")) { statement.execute(); return 1; } return statement.executeUpdateDelete(); } finally { statement.close(); } } finally { releaseReference(); } }
/** * Deletes any empty folder from the DB. * @return Ids of deleted folders. */ private ArrayList<Long> deleteEmptyFolders() { ArrayList<Long> folderIds = new ArrayList<>(); SQLiteDatabase db = mOpenHelper.getWritableDatabase(); db.beginTransaction(); try { // Select folders whose id do not match any container value. String selection = LauncherSettings.Favorites.ITEM_TYPE + " = " + LauncherSettings.Favorites.ITEM_TYPE_FOLDER + " AND " + LauncherSettings.Favorites._ID + " NOT IN (SELECT " + LauncherSettings.Favorites.CONTAINER + " FROM " + Favorites.TABLE_NAME + ")"; Cursor c = db.query(Favorites.TABLE_NAME, new String[] {LauncherSettings.Favorites._ID}, selection, null, null, null, null); while (c.moveToNext()) { folderIds.add(c.getLong(0)); } c.close(); if (!folderIds.isEmpty()) { db.delete(Favorites.TABLE_NAME, Utilities.createDbSelectionQuery( LauncherSettings.Favorites._ID, folderIds), null); } db.setTransactionSuccessful(); } catch (SQLException ex) { Log.e(TAG, ex.getMessage(), ex); folderIds.clear(); } finally { db.endTransaction(); } return folderIds; }
public void onCreate(SQLiteDatabase db) { try { db.execSQL(CREATE_MAINTABLE_HIDES); } catch (SQLException e) { FirebaseCrash.report(e); e.printStackTrace(); } }
boolean insertReceivedEvent(GameHarvest event) { try { mDatabase = mDbHelper.getWritableDatabase(); QueryConditionList whereConditions = new QueryConditionList(); whereConditions.add(DiaryHelper.COLUMN_ID + " = " + event.mId, null); addCommonWhereConditions(whereConditions); String query = "SELECT * FROM " + DiaryHelper.TABLE_DIARY + " WHERE " + whereConditions.getWhereCondition(); Cursor cursor = mDatabase.rawQuery(query, whereConditions.getValueArray()); if (cursor.getCount() == 0) { addLocalEvent(event, true); return true; } else { cursor.moveToFirst(); boolean isRemote = (cursor.getInt(cursor.getColumnIndex(DiaryHelper.COLUMN_REMOTE)) == 1); boolean isSent = (cursor.getInt(cursor.getColumnIndex(DiaryHelper.COLUMN_SENT)) == 1); int currentRev = cursor.getInt(cursor.getColumnIndex(DiaryHelper.COLUMN_REV)); int storedFormatVersion = cursor.getInt(cursor.getColumnIndex(DiaryHelper.COLUMN_CLIENT_DATA_FORMAT)); // Event can be replaced if server rev is newer or if it's same and the event has not been modified if (!isRemote || event.mRev > currentRev || (event.mClientDataFormat > storedFormatVersion && isSent) || (event.mRev == currentRev && isSent)) { cursor.moveToFirst(); event.mLocalId = cursor.getInt(cursor.getColumnIndex(DiaryHelper.COLUMN_LOCALID)); editLocalEvent(event, true); return true; } } } catch (SQLException e) { e.printStackTrace(); } return false; }
public NISTDBAdapter open() throws SQLException { try { mDbHelper.openDataBase(); mDbHelper.close(); mDb = mDbHelper.getReadableDatabase(); } catch (SQLException mSQLException) { Log.e(TAG, "open >>"+ mSQLException.toString()); throw mSQLException; } return this; }
public Cursor getContact(long rowId) throws SQLException { Cursor mCursor = db.query(true, DATABASE_TABLE, new String[]{ KEY_ROWID, KEY_NAME, KEY_PHONENUM}, KEY_ROWID + "=" + rowId, null, null, null, null, null); if (mCursor != null) mCursor.moveToFirst(); return mCursor; }
/** * Method is used to create the db tables. It accepts a SQLite db object. * * @param db the acsepted SQLite object */ @Override public void onCreate(SQLiteDatabase db) { try { /* * Creates the Item table */ db.execSQL(CREATE_ITEM_TABLE_QUERY); Log.e("DATABASE OPERATIONS", "...Item table created!"); /* * Creates the Category table */ db.execSQL(CREATE_CATEGORY_TABLE_QUERY); Log.e("DATABASE OPERATIONS", "...Category table created!"); /* * Creates the User Registration table */ db.execSQL(CREATE_USER_REGISTRATION_TABLE_QUERY); Log.e("DATABASE OPERATIONS", "...User Registration table created!"); insertDefaultCategoryBooks(db); insertDefaultCategoryClothes(db); insertDefaultCategoryAccessories(db); insertDefaultCategoryGames(db); insertDefaultCategoryOther(db); Log.e("DATABASE OPERATIONS", "...Default categories created successfully!"); } catch (SQLException ex) { Log.e("DATABASE OPERATIONS", "Unable to perform default DDL & DML operations!", ex); } }
@Override public void onCreate(SQLiteDatabase db) { try { db.execSQL(DATABASE_CREATION); } catch (SQLException e) { e.printStackTrace(); } }
/** * Compiles an SQL statement into a reusable pre-compiled statement object. * The parameters are identical to {@link #execSQL(String)}. You may put ?s in the * statement and fill in those values with {@link SQLiteProgram#bindString} * and {@link SQLiteProgram#bindLong} each time you want to run the * statement. Statements may not return result sets larger than 1x1. * <p> * No two threads should be using the same {@link SQLiteStatement} at the same time. * * @param sql The raw SQL statement, may contain ? for unknown values to be * bound later. * @return A pre-compiled {@link SQLiteStatement} object. Note that * {@link SQLiteStatement}s are not synchronized, see the documentation for more details. */ public SQLiteStatement compileStatement(String sql) throws SQLException { acquireReference(); try { ShadowSQLiteStatement shadowSQLiteStatement = new ShadowSQLiteStatement(this, sql, null); // SQLiteDatabase db, String sql, Object[] bindArgs // Class[] argTypes = new Class[]{SQLiteDatabase.class, String.class, Object[].class}; // SQLiteStatement只有 public SQLiteStatement()构造函数 return new CGLibProxy().proxy(SQLiteStatement.class, shadowSQLiteStatement); } finally { releaseReference(); } }
public DBQuery open() throws SQLException { try { dbHelper.openDataBase(); dbHelper.close(); db = dbHelper.getReadableDatabase(); } catch (SQLException ignored) { } return this; }
@Thunk boolean updateFolderItemsRank(SQLiteDatabase db, boolean addRankColumn) { db.beginTransaction(); try { if (addRankColumn) { // Insert new column for holding rank db.execSQL("ALTER TABLE favorites ADD COLUMN rank INTEGER NOT NULL DEFAULT 0;"); } // Get a map for folder ID to folder width Cursor c = db.rawQuery("SELECT container, MAX(cellX) FROM favorites" + " WHERE container IN (SELECT _id FROM favorites WHERE itemType = ?)" + " GROUP BY container;", new String[] {Integer.toString(LauncherSettings.Favorites.ITEM_TYPE_FOLDER)}); while (c.moveToNext()) { db.execSQL("UPDATE favorites SET rank=cellX+(cellY*?) WHERE " + "container=? AND cellX IS NOT NULL AND cellY IS NOT NULL;", new Object[] {c.getLong(1) + 1, c.getLong(0)}); } c.close(); db.setTransactionSuccessful(); } catch (SQLException ex) { // Old version remains, which means we wipe old data ex.printStackTrace(); return false; } finally { db.endTransaction(); } return true; }
@Override public Uri insert(@NonNull Uri uri, ContentValues values) { final SQLiteDatabase db_g = mOpenHelper_gallery.getReadableDatabase(); final SQLiteDatabase db_a = mOpenHelper_article.getReadableDatabase(); final int match = sUriMatcher.match(uri); Uri returnUri; switch (match) { case IMAGE: long _id = db_g.insert(TABLE_NAME_GALLERY, null, values); if (_id > 0) { returnUri = GalleryEntry.buildGalleryUri(_id); } else { throw new SQLException("Failed to add a record into " + uri); } break; case ARTICLE: long id = db_a.insert(TABLE_NAME_ARTICLE, null, values); if (id > 0) { returnUri = ArticleEntry.buildArticleUri(id); } else { throw new SQLException("Failed to add a record into " + uri); } break; default: throw new UnsupportedOperationException("Unknown uri: " + uri); } getContext().getContentResolver().notifyChange(uri, null); db_g.close(); db_a.close(); return returnUri; }
public static Cursor getCursorForBook(Context context, String bookName) throws SQLException { /* Create a query with a book name condition. */ InternalQueryBuilder builder = new InternalQueryBuilder(); String query = builder.build(new Query(new Condition.InBook(bookName))); return context.getContentResolver().query( ProviderContract.Notes.ContentUri.notesSearchQueried(query), null, null, null, DbNoteView.LFT); // For book view, force ordering by position only }
public void onCreate(SQLiteDatabase db) { try { db.execSQL(userDBAdapter.CREATE_MAINTABLE_USER); } catch (SQLException e) { FirebaseCrash.report(e); e.printStackTrace(); } }
private boolean addIntegerColumn(SQLiteDatabase db, String columnName, long defaultValue) { db.beginTransaction(); try { db.execSQL("ALTER TABLE favorites ADD COLUMN " + columnName + " INTEGER NOT NULL DEFAULT " + defaultValue + ";"); db.setTransactionSuccessful(); } catch (SQLException ex) { Log.e(TAG, ex.getMessage(), ex); return false; } finally { db.endTransaction(); } return true; }
@Override public void close() throws SQLException { if (DEBUG) { MyLog.i(CLS_NAME, "close"); } database.close(); }