Java 类android.database.sqlite.SQLiteOpenHelper 实例源码

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);


}

/**
 * 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);


}

/**
 * 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);


}

/**
 * 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);


}

/**
 * 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);
}