Java BriteDatabase类代码示例

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
/**
 * 更新TaskBundle
 */
public void updateTaskBundle(TaskBundle taskBundle) {

  //更新 有可能是
  if (taskBundle.getTaskList() == null || taskBundle.getTaskList().size() == 0) {
    db.update(TaskBundle.TASK_BUNDLE_TABLE_NAME, getTaskBundleValues(taskBundle),
        TaskBundle.COLUMN_KEY + "=?", taskBundle.getKey());
  } else {
    if (!isExistTaskEntity(taskBundle.getBundleId())) {
      BriteDatabase.Transaction transaction = db.newTransaction();
      db.update(TaskBundle.TASK_BUNDLE_TABLE_NAME, getTaskBundleValues(taskBundle),
          TaskBundle.COLUMN_KEY + "=?", taskBundle.getKey());
      int nextTaskId = getNextID(db, TaskEntity.TASK_TABLE_NAME, TaskEntity.COLUMN_TASK_ID);
      for (TaskEntity taskEntity : taskBundle.getTaskList()) {
        taskEntity.setTaskBundleId(taskBundle.getBundleId());
        taskEntity.setTaskId(nextTaskId);
        db.insert(TaskEntity.TASK_TABLE_NAME, getTaskEntity(taskEntity));
        nextTaskId++;
      }
      transaction.markSuccessful();
      transaction.end();
    }
    db.update(TaskBundle.TASK_BUNDLE_TABLE_NAME, getTaskBundleValues(taskBundle),
        TaskBundle.COLUMN_KEY + "=?", taskBundle.getKey());
  }
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
private int getNextID(BriteDatabase db, String tableName, String idName) {
  StringBuilder sqlB = new StringBuilder();
  sqlB.append("SELECT max(").append(idName).append(") AS maxId ");
  sqlB.append("FROM ").append(tableName);
  L.i("max id " + sqlB.toString());
  int maxId = 1;
  Cursor cursor = db.query(sqlB.toString());
  if (cursor.moveToFirst()) {
    maxId = DBHelper.getInt(cursor, "maxId");

    if (maxId >= 0) {
      return maxId + 1;
    }
  }
  cursor.close();
  return maxId;
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public long insert(BriteDatabase db, Library library) {
  synchronized (this) {
    insertLibrary.bind(
        library.id(),
        library.packageName(),
        library.sourceDir(),
        library.title(),
        library.subtitle(),
        library.description(),
        library.websiteUrl(),
        library.type(),
        library.createdAt(),
        library.updatedAt());

    return db.executeInsert(insertLibrary.table, insertLibrary.program);
  }
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public int update(BriteDatabase db, Library library) {
  synchronized (this) {
    updateLibrary.bind(
        library.packageName(),
        library.sourceDir(),
        library.title(),
        library.subtitle(),
        library.description(),
        library.websiteUrl(),
        library.type(),
        library.createdAt(),
        library.updatedAt(),
        library.id());

    return db.executeUpdateDelete(updateLibrary.table, updateLibrary.program);
  }
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Repository(Context context) {
    SchedulerProvider schedulerProvider = DefaultSchedulerProvider.getInstance();
    DbHelper openHelper = new DbHelper(context);
    SqlBrite sqlBrite = new SqlBrite.Builder().build();
    // TODO: switch to the rxjava2 scheduler when new sqlbrite will be released
    BriteDatabase briteDatabase = sqlBrite.wrapDatabaseHelper(openHelper, Schedulers.io());

    if (BuildConfig.DEBUG) {
        briteDatabase.setLoggingEnabled(true);
    }

    briteDatabaseHelper = new BriteDatabaseHelper(briteDatabase);

    Dependencies dependencies = new Dependencies(context, this, briteDatabaseHelper,
            schedulerProvider);

    artistRepository = new ArtistRepository(dependencies);
    locationRepository = new LocationRepository(dependencies);
    concertRepository = new ConcertRepository(dependencies);
    syncStateRepository = new SyncStateRepository(dependencies);
    syncRepository = new SyncRepository(dependencies);
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Completable deleteArtists(List<Artist> artists) {
    return Completable.fromAction(() -> {
        try (BriteDatabase.Transaction transaction =
                     dbHelper.getBriteDatabase().newTransaction()) {
            Observable.fromIterable(artists).blockingForEach(artist -> {
                dbHelper.blockingDeleteByValue(entityRegistry.artist.getTableName(),
                        entityRegistry.artist.getIdColumn(),
                        artist.getId());
                dbHelper.blockingDeleteByValue(entityRegistry.concert.getTableName(),
                        Contract.ConcertsTable.COLUMN_ARTIST_ID, artist.getId());
                dbHelper.blockingDeleteByValue(entityRegistry.syncState.getTableName(),
                        Contract.SyncStatesTable.COLUMN_ARTIST_ID, artist.getId());
            });
            transaction.markSuccessful();
        }
    })
            .subscribeOn(schedulerProvider.io());
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public void addPackages(List<PackageInfo> packageInfos) {
  BriteDatabase db = databaseManager.get();
  try (BriteDatabase.Transaction transaction = db.newTransaction()) {

    for (PackageInfo packageInfo : packageInfos) {
      App app = toAppMapper.map(packageInfo.applicationInfo);
      long appId = appRepository.insertOrUpdate(db, app);

      Version version = new ToVersionMapper(clock, appId).map(packageInfo);
      versionRepository.insert(db, version);

      String thread = Thread.currentThread().getName();
      Timber.d("%s : inserted app %s, %s", thread, app.packageName(), version.versionName());
    }

    transaction.markSuccessful();
  }
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public void insertOrUpdate(List<Permission> permissions) {
  BriteDatabase db = databaseManager.get();
  try (BriteDatabase.Transaction transaction = db.newTransaction()) {
    for (Permission permission : permissions) {
      PermissionGroup group = getGroup(permission.permissionGroup());

      if (group != null) {
        insertOrUpdate(group);
      }

      int updatedRows = permissionRepository.update(db, permission);

      if (updatedRows == 0) {
        permissionRepository.insert(db, permission);
      }
    }
    transaction.markSuccessful();
  }
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Observable<Ribot> setRibots(final Collection<Ribot> newRibots) {
    return Observable.create(new Observable.OnSubscribe<Ribot>() {
        @Override
        public void call(Subscriber<? super Ribot> subscriber) {
            if (subscriber.isUnsubscribed()) return;
            BriteDatabase.Transaction transaction = mDb.newTransaction();
            try {
                mDb.delete(Db.RibotProfileTable.TABLE_NAME, null);
                for (Ribot ribot : newRibots) {
                    long result = mDb.insert(Db.RibotProfileTable.TABLE_NAME,
                            Db.RibotProfileTable.toContentValues(ribot.profile()),
                            SQLiteDatabase.CONFLICT_REPLACE);
                    if (result >= 0) subscriber.onNext(ribot);
                }
                transaction.markSuccessful();
                subscriber.onCompleted();
            } finally {
                transaction.end();
            }
        }
    });
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Observable<ProductListResponse> setProducts(final ProductListResponse productListResponse) {
    return Observable.create(new Observable.OnSubscribe<ProductListResponse>() {
        @Override
        public void call(Subscriber<? super ProductListResponse> subscriber) {
            if (subscriber.isUnsubscribed()) return;
            BriteDatabase.Transaction transaction = mDb.newTransaction();
            try {
                mDb.delete(Db.ProductProfileTable.TABLE_NAME, null);
                for (ProductListResponse.Product product : productListResponse.getList()) {
                    long result = mDb.insert(Db.ProductProfileTable.TABLE_NAME,
                            Db.ProductProfileTable.toContentValues(product),
                            SQLiteDatabase.CONFLICT_REPLACE);
                    if (result >= 0) subscriber.onNext(productListResponse);
                }
                transaction.markSuccessful();
                subscriber.onCompleted();
            } finally {
                transaction.end();
            }
        }
    });
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Completable saveLocations(List<Location> locations) {
    return Completable.fromAction(() -> {
        try (BriteDatabase.Transaction transaction =
                     dbHelper.getBriteDatabase().newTransaction()) {
            List<Artist> artists = dbHelper.selectAll(entityRegistry.artist,
                    entityRegistry.artist.getIdColumn());
            Observable<Artist> artistObservable = Observable.fromIterable(artists);

            Observable.fromIterable(locations).blockingForEach(location -> {
                dbHelper.getBriteDatabase().insert(
                        entityRegistry.location.getTableName(),
                        entityRegistry.location.toContentValues(location));
                syncStateRepository.resetSyncStates(artistObservable, location);
            });

            transaction.markSuccessful();
        }
    })
            .doOnComplete(() -> SyncManager.requestSync(context))
            .subscribeOn(schedulerProvider.io());
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public Completable deleteLocation(Location location) {
    return Completable.fromAction(() -> {
        try (BriteDatabase.Transaction transaction =
                     dbHelper.getBriteDatabase().newTransaction()) {
            dbHelper.blockingDeleteByValue(entityRegistry.location.getTableName(),
                    entityRegistry.location.getIdColumn(), location.getId());
            dbHelper.blockingDeleteByValue(entityRegistry.concert.getTableName(),
                    Contract.ConcertsTable.COLUMN_LOCATION_ID, location.getId());
            dbHelper.blockingDeleteByValue(entityRegistry.syncState.getTableName(),
                    Contract.SyncStatesTable.COLUMN_LOCATION_ID, location.getId());

            transaction.markSuccessful();
        }
    })
            .subscribeOn(schedulerProvider.io());
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
@Provides
@Singleton
BriteDatabase provideDatabase(SqlBrite sqlBrite, SQLiteOpenHelper helper) {
    BriteDatabase db = sqlBrite.wrapDatabaseHelper(helper, Schedulers.io());
    db.setLoggingEnabled(true);
    return db;
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
public int insertOrUpdateInTransaction(final String table, final List<ContentValues> batch) {
    final BriteDatabase.Transaction transaction = briteDatabase.newTransaction();
    int updatedRows = 0;
    try {
        for (final ContentValues cv : batch) {
            updatedRows += (insertOrUpdate(table, cv) >= 0 ? 1 : 0);
        }
        transaction.markSuccessful();
    } finally {
        transaction.end();
    }
    return updatedRows;
}
 

import com.squareup.sqlbrite.BriteDatabase; //导入依赖的package包/类
/**
 * 插入TaskBundle
 */
public void insertTaskBundle(TaskBundle taskBundle) {
  if (!isExistTaskBundle(taskBundle.getKey())) {
    BriteDatabase.Transaction transaction = db.newTransaction();
    try {
      int nextBundleId =
          getNextID(db, TaskBundle.TASK_BUNDLE_TABLE_NAME, TaskBundle.COLUMN_BUNDLE_ID);
      db.insert(TaskBundle.TASK_BUNDLE_TABLE_NAME, getTaskBundleValues(taskBundle));
      List<TaskEntity> taskList = taskBundle.getTaskList();

      taskBundle.setBundleId(nextBundleId);

      if (taskList != null && taskList.size() > 0) {
        int nextTaskId = getNextID(db, TaskEntity.TASK_TABLE_NAME, TaskEntity.COLUMN_TASK_ID);
        for (TaskEntity taskEntity : taskList) {
          taskEntity.setTaskBundleId(nextBundleId);
          taskEntity.setTaskId(nextTaskId);
          db.insert(TaskEntity.TASK_TABLE_NAME, getTaskEntity(taskEntity));
          nextTaskId++;
        }
      }
      transaction.markSuccessful();
    } finally {
      transaction.end();
    }
  } else {
    TaskBundle bundleByKey = getBundleByKey(taskBundle.getKey());
    taskBundle.init(bundleByKey);
  }
}