public SQLiteDatabaseWrapper borrowObject() throws Exception { synchronized (pool) { if (!initialized) { for (int i = 0; i < connections; i++) { // Initialize! SQLiteOpenHelper outerSqLiteOpenHelper; if(dbName == null) outerSqLiteOpenHelper = createSQLiteOpenHelperInstance(); else outerSqLiteOpenHelper = createSQLiteOpenHelperInstance(dbName); pool.add(new SQLiteDatabaseWrapper(outerSqLiteOpenHelper)); } initialized = true; } // wait until there is an available connection while (pool.size() == 0) { pool.wait(); } return pool.remove(0); } }
public List<HistoryItem> buildHistoryItems() { SQLiteOpenHelper helper = new DBHelper(activity); List<HistoryItem> items = new ArrayList<>(); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getReadableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, COLUMNS, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC"); while (cursor.moveToNext()) { String text = cursor.getString(0); String display = cursor.getString(1); String format = cursor.getString(2); long timestamp = cursor.getLong(3); String details = cursor.getString(4); Result result = new Result(text, null, null, BarcodeFormat.valueOf(format), timestamp); items.add(new HistoryItem(result, display, details)); } } finally { close(cursor, db); } return items; }
public HistoryItem buildHistoryItem(int number) { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getReadableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, COLUMNS, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC"); cursor.move(number + 1); String text = cursor.getString(0); String display = cursor.getString(1); String format = cursor.getString(2); long timestamp = cursor.getLong(3); String details = cursor.getString(4); Result result = new Result(text, null, null, BarcodeFormat.valueOf(format), timestamp); return new HistoryItem(result, display, details); } finally { close(cursor, db); } }
public void deleteHistoryItem(int number) { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getWritableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, ID_COL_PROJECTION, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC"); cursor.move(number + 1); db.delete(DBHelper.TABLE_NAME, DBHelper.ID_COL + '=' + cursor.getString(0), null); } finally { close(cursor, db); } }
public void trimHistory() { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getWritableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, ID_COL_PROJECTION, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC"); cursor.move(MAX_ITEMS); while (cursor.moveToNext()) { String id = cursor.getString(0); Log.i(TAG, "Deleting scan history ID " + id); db.delete(DBHelper.TABLE_NAME, DBHelper.ID_COL + '=' + id, null); } } catch (SQLiteException sqle) { // We're seeing an error here when called in CaptureActivity.onCreate() in rare cases // and don't understand it. First theory is that it's transient so can be safely ignored. Log.w(TAG, sqle); // continue } finally { close(cursor, db); } }
/** * Upgrade existing database. */ @Test public void sequentialUpgrade() { final Context ctx = RuntimeEnvironment.application.getApplicationContext(); final int[] versions = new int[]{1, 2, 3}; for (int i = 1; i <= 3; i++) { final SQLiteOpenHelper unit = new DBUnit(ctx, i); final SQLiteDatabase db = unit.getReadableDatabase(); Cursor cursor = null; try { cursor = db.rawQuery("SELECT value FROM versions", new String[0]); assertVersions(cursor, Arrays.copyOf(versions, i)); } finally { if (cursor != null) { cursor.close(); } db.close(); } unit.close(); } }
/** * Apply migrations from custom folder. */ @Test public void customFolder() { final Context ctx = RuntimeEnvironment.application; final SQLiteOpenHelper unit = new DBUnit(ctx, 1, "custom_migrations"); final SQLiteDatabase database = unit.getReadableDatabase(); Cursor cursor = null; try { cursor = database.rawQuery("SELECT value FROM custom_versions", new String[0]); assertVersions(cursor, 1); } finally { if (cursor != null) { cursor.close(); } database.close(); } }
@Provides @Singleton BriteDatabase provideDatabase(SqlBrite sqlBrite, SQLiteOpenHelper helper) { BriteDatabase db = sqlBrite.wrapDatabaseHelper(helper, Schedulers.io()); db.setLoggingEnabled(true); return db; }
protected SQLiteOpenHelper createSQLiteOpenHelperInstance() throws Exception { // We want the constructor with Context parameter Constructor<?> cons = sqliteOpenHelperClass.getConstructor(new Class[] { Context.class }); // We create the instance! return (SQLiteOpenHelper) cons.newInstance(context); }
protected SQLiteOpenHelper createSQLiteOpenHelperInstance(String dbName) throws Exception { // We want the constructor with Context parameter Constructor<?> cons = sqliteOpenHelperClass.getConstructor(new Class[] { Context.class, String.class }); // We create the instance! return (SQLiteOpenHelper) cons.newInstance(context, dbName); }
@Override public boolean onCreate() { try { SQLiteOpenHelper databaseHelper = new Database(getContext(), DATABASE_NAME, null, DATABASE_VERSION); database = databaseHelper.getWritableDatabase(); return (database != null) ? true : false; } catch (Exception e) { Log.e("DatabaseProvider", "onCreate : " + e); return false; } }
public boolean hasHistoryItems() { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getReadableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, COUNT_COLUMN, null, null, null, null, null); cursor.moveToFirst(); return cursor.getInt(0) > 0; } finally { close(cursor, db); } }
public void addHistoryItem(Result result, ResultHandler handler) { // Do not save this item to the history if the preference is turned off, or the contents are // considered secure. if (!activity.getIntent().getBooleanExtra(Intents.Scan.SAVE_HISTORY, true) || handler.areContentsSecure() || !enableHistory) { return; } SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity); if (!prefs.getBoolean(PreferencesActivity.KEY_REMEMBER_DUPLICATES, false)) { deletePrevious(result.getText()); } ContentValues values = new ContentValues(); values.put(DBHelper.TEXT_COL, result.getText()); values.put(DBHelper.FORMAT_COL, result.getBarcodeFormat().toString()); values.put(DBHelper.DISPLAY_COL, handler.getDisplayContents().toString()); values.put(DBHelper.TIMESTAMP_COL, System.currentTimeMillis()); SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; try { db = helper.getWritableDatabase(); // Insert the new entry into the DB. db.insert(DBHelper.TABLE_NAME, DBHelper.TIMESTAMP_COL, values); } finally { close(null, db); } }
private void deletePrevious(String text) { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; try { db = helper.getWritableDatabase(); db.delete(DBHelper.TABLE_NAME, DBHelper.TEXT_COL + "=?", new String[] { text }); } finally { close(null, db); } }
/** * <p>Builds a text representation of the scanning history. Each scan is encoded on one * line, terminated by a line break (\r\n). The values in each line are comma-separated, * and double-quoted. Double-quotes within values are escaped with a sequence of two * double-quotes. The fields output are:</p> * * <ol> * <li>Raw text</li> * <li>Display text</li> * <li>Format (e.g. QR_CODE)</li> * <li>Unix timestamp (milliseconds since the epoch)</li> * <li>Formatted version of timestamp</li> * <li>Supplemental info (e.g. price info for a product barcode)</li> * </ol> */ CharSequence buildHistory() { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; Cursor cursor = null; try { db = helper.getWritableDatabase(); cursor = db.query(DBHelper.TABLE_NAME, COLUMNS, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC"); DateFormat format = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM); StringBuilder historyText = new StringBuilder(1000); while (cursor.moveToNext()) { historyText.append('"').append(massageHistoryField(cursor.getString(0))).append("\","); historyText.append('"').append(massageHistoryField(cursor.getString(1))).append("\","); historyText.append('"').append(massageHistoryField(cursor.getString(2))).append("\","); historyText.append('"').append(massageHistoryField(cursor.getString(3))).append("\","); // Add timestamp again, formatted long timestamp = cursor.getLong(3); historyText.append('"').append(massageHistoryField( format.format(new Date(timestamp)))).append("\","); // Above we're preserving the old ordering of columns which had formatted data in position 5 historyText.append('"').append(massageHistoryField(cursor.getString(4))).append("\"\r\n"); } return historyText; } finally { close(cursor, db); } }
void clearHistory() { SQLiteOpenHelper helper = new DBHelper(activity); SQLiteDatabase db = null; try { db = helper.getWritableDatabase(); db.delete(DBHelper.TABLE_NAME, null, null); } finally { close(null, db); } }
/** * Tests to ensure that inserts into your database results in automatically * incrementing row IDs. * @throws Exception in case the constructor hasn't been implemented yet */ @Test public void autoincrement_test() throws Exception{ /* First, let's ensure we have some values in our table initially */ insert_single_record_test(); /* Use reflection to try to run the correct constructor whenever implemented */ SQLiteOpenHelper dbHelper = (SQLiteOpenHelper) mDbHelperClass.getConstructor(Context.class).newInstance(mContext); /* Use WaitlistDbHelper to get access to a writable database */ SQLiteDatabase database = dbHelper.getWritableDatabase(); ContentValues testValues = new ContentValues(); testValues.put(WaitlistContract.WaitlistEntry.COLUMN_GUEST_NAME, "test name"); testValues.put(WaitlistContract.WaitlistEntry.COLUMN_PARTY_SIZE, 99); /* Insert ContentValues into database and get first row ID back */ long firstRowId = database.insert( WaitlistContract.WaitlistEntry.TABLE_NAME, null, testValues); /* Insert ContentValues into database and get another row ID back */ long secondRowId = database.insert( WaitlistContract.WaitlistEntry.TABLE_NAME, null, testValues); assertEquals("ID Autoincrement test failed!", firstRowId + 1, secondRowId); }
public synchronized static void init(Context context, String databaseName) { SQLiteOpenHelper helper = new OrmSQLiteOpenHelper(context, databaseName, 1, null); sDatabase = helper.getWritableDatabase(); if (sDatabase != null) { sDatabaseState = STATE_DATABASE_EXISTS; } }
public synchronized static void init(Context context, OrmConfig config) { String name = config.getDatabaseName(); int versionCode = config.getVersionCode(); Class<? extends OrmTable>[] tables = config.getTables(); SQLiteOpenHelper helper = new OrmSQLiteOpenHelper(context, name, versionCode, tables); sDatabase = helper.getWritableDatabase(); if (sDatabase != null) { sDatabaseState = STATE_DATABASE_EXISTS; } }
private SQLiteOpenHelper findDatabaseHelper(Application application) { final String className = "com.github.florent37.rxandroidorm.DatabaseHelper"; try { Class<?> clazz = Class.forName(className); Constructor<?> constructor = clazz.getConstructor(Context.class); return (SQLiteOpenHelper) constructor.newInstance(application); } catch (Exception e) { Log.e(TAG, "cannot construct RxAndroidOrm", e); } return null; }
public void createdb(View v) { CursorFactory factory = null; int version = 1;// �Զ�����1��ʼ String name = "db.db";// ���ݿ��� Context Context = v.getContext(); // ʹ��sqlliteopenhelpeʵ������ȡһ��sqldatabase SQLiteOpenHelper helper = new MySQLiteOpenHelper(Context, name, factory, version); SQLiteDatabase db = helper.getWritableDatabase(); }
/** * @inheritDoc */ @Override @AddTrace(name="StationsDb.getStationById") public Station getStationById(String id) { SQLiteOpenHelper StationsDbHelper = new StationsDb(context); SQLiteDatabase db = StationsDbHelper.getReadableDatabase(); Cursor c = db.query( StationsDataColumns.TABLE_NAME, new String[]{ StationsDataColumns._ID, StationsDataColumns.COLUMN_NAME_NAME, StationsDataColumns.COLUMN_NAME_ALTERNATIVE_NL, StationsDataColumns.COLUMN_NAME_ALTERNATIVE_FR, StationsDataColumns.COLUMN_NAME_ALTERNATIVE_DE, StationsDataColumns.COLUMN_NAME_ALTERNATIVE_EN, StationsDataColumns.COLUMN_NAME_COUNTRY_CODE, StationsDataColumns.COLUMN_NAME_LATITUDE, StationsDataColumns.COLUMN_NAME_LONGITUDE, StationsDataColumns.COLUMN_NAME_AVG_STOP_TIMES }, StationsDataColumns._ID + "=?", new String[]{id}, null, null, null, "1"); Station[] results = loadStationCursor(c); c.close(); db.close(); if (results == null) { return null; } return results[0]; }
@SuppressWarnings("ConstantConditions") // Public API contract validation. @CheckResult @NonNull public static BriteDatabaseBridge create(@NonNull SQLiteOpenHelper helper, @NonNull com.squareup.sqlbrite.SqlBrite sqlBrite1, @NonNull rx.Scheduler scheduler1, @NonNull com.squareup.sqlbrite2.SqlBrite sqlBrite2, @NonNull io.reactivex.Scheduler scheduler2) { if (helper == null) throw new NullPointerException("helper == null"); if (sqlBrite1 == null) throw new NullPointerException("sqlBrite1 == null"); if (scheduler1 == null) throw new NullPointerException("scheduler1 == null"); if (sqlBrite2 == null) throw new NullPointerException("sqlBrite2 == null"); if (scheduler2 == null) throw new NullPointerException("scheduler2 == null"); return new BriteDatabaseBridge(helper, sqlBrite1, scheduler1, sqlBrite2, scheduler2); }
private BriteDatabaseBridge(SQLiteOpenHelper helper, com.squareup.sqlbrite.SqlBrite sqlBrite1, rx.Scheduler scheduler1, com.squareup.sqlbrite2.SqlBrite sqlBrite2, io.reactivex.Scheduler scheduler2) { io.reactivex.subjects.PublishSubject<Set<String>> source2 = io.reactivex.subjects.PublishSubject.create(); rx.subjects.PublishSubject<Set<String>> source1 = rx.subjects.PublishSubject.create(); MultiSubjectDispatcher<Set<String>> sink = new MultiSubjectDispatcher<>(source1, source2); database1 = BriteDatabaseV1Factory.create(sqlBrite1, helper, source1, sink, scheduler1); database2 = BriteDatabaseV2Factory.create(sqlBrite2, helper, source2, sink, scheduler2); }
@Override public SQLiteOpenHelper openHelper(Context context) { return new ProviGenOpenHelper(getContext(), DB_NAME, null, 1, CONTRACTS); }
public BaseDao(SQLiteOpenHelper helper) { TAG = getClass().getSimpleName(); lock = DBHelper.lock; this.helper = helper; this.database = openWriter(); }
@Test public void migrationsFromDbVersion42Onward() { SQLiteOpenHelper opener = new MigrationRunningOpenHelper(context); opener.getReadableDatabase(); }
public MmsDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); this.jobManager = ApplicationContext.getInstance(context).getJobManager(); }
public RecipientPreferenceDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public GroupDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public DraftDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public MessagingDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public EncryptingSmsDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public PushDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public MmsSmsDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }
public IdentityDatabase(Context context, SQLiteOpenHelper databaseHelper) { super(context, databaseHelper); }