import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
public int getTimes(ScriptSource source) {
    ScriptStaticsRecord record = mStorIOSQLite.get()
            .object(ScriptStaticsRecord.class)
            .withQuery(Query.builder()
                    .table(TABLE_NAME)
                    .where("name = ?")
                    .whereArgs(source.toString())
                    .build())
            .prepare()
            .executeAsBlocking();
    if (record != null) {
        return record.times;
    } else {
        return 0;
    }
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@RxLogObservable
public Observable<List<Position>> getPositions(List<Long> ids) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < ids.size(); i ++) {
        builder.append("_id = ?");
        if (i != ids.size() - 1) {
            builder.append(" OR ");
        }
    }

    return storIOSQLite
            .get()
            .listOfObjects(Position.class)
            .withQuery(Query.builder().table(PositionsTable.TABLE)
                    .where(builder.toString())
                    .whereArgs(ids)
                    .build()
            )
            .prepare()
            .asRxObservable();
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void getFavorites() {
    DefaultStorIOSQLite storio = GtApplication.getInstance().getStorIOSQLite();
    Query q = Query.builder()
            .table(FavoritesTable.TABLE)
            .build();

    storio.get()
            .listOfObjects(Favorite.class)
            .withQuery(q)
            .prepare()
            .asRxObservable()
            .observeOn(Schedulers.io())
            .subscribe(favorites -> {
                Timber.d("Got %s faves", favorites.size());
            }, throwable -> {
                Timber.d("Error getting favorites from DB");
                Timber.d(throwable.getCause().toString());
                Timber.d(throwable.toString());
            });
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
/**
 * This is for use the GtActionCreator only.
 * This will also add the Favorite to the store
 *
 * @return An rx.Single for the favorites list
 */
private Single<HashMap<String, Favorite>> getFavoritesInternal(int type) {
    DefaultStorIOSQLite storio = GtApplication.getInstance().getStorIOSQLite();
    Query q = Query.builder()
            .table(FavoritesTable.TABLE)
            .where(FavoritesTable.COLUMN_TYPE + "=?")
            .whereArgs(type)
            .build();

    return storio.get()
            .listOfObjects(Favorite.class)
            .withQuery(q)
            .prepare()
            .asRxSingle()
            .map(favorites -> {
                HashMap<String, Favorite> hm = new HashMap<>(favorites.size());
                for (Favorite favorite : favorites) {
                    hm.put(favorite.reference, favorite);
                }
                return hm;
            });
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@Override
protected void onResume() {
    super.onResume();

    // QUERY
    sq.get().listOfObjects(Item.class)
            .withQuery(Query.builder().table("Items").build()).prepare().asRxObservable()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(items -> {
                Log.d("Example2", "Queried items");
                adapter.setItems(items);
            });

    // DELETE
    mListView.setOnItemClickListener((adapterView, view, i, l) ->
            sq.delete().object(adapter.getItem(i)).prepare().asRxCompletable()
            .observeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(() -> {
                Log.d("Example2", "Deleted row");
            }));
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private Observable<List<SyncIdItem>> getGroupObservable() {
    return mStorIOSQLite.get()
            .listOfObjects(StudentGroup.class)
            .withQuery(Query.builder()
                    .table(StudentGroupEntry.TABLE_NAME)
                    .where(StudentGroupEntry.COL_IS_CACHED + " = ?")
                    .whereArgs("1")
                    .build())
            .prepare()
            .createObservable()
            .take(1)
            .flatMap(Observable::from)
            .map(studentGroup -> new SyncIdItem(studentGroup.id, studentGroup.name, true))
            .toList()
            .subscribeOn(Schedulers.computation())
            .observeOn(AndroidSchedulers.mainThread());
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private Observable<List<SyncIdItem>> getEmployeeObservable() {
    return mStorIOSQLite.get()
            .listOfObjects(Employee.class)
            .withQuery(Query.builder()
                    .table(EmployeeEntry.TABLE_NAME)
                    .where(EmployeeEntry.COL_IS_CACHED + " = ?")
                    .whereArgs("1")
                    .build())
            .prepare()
            .createObservable()
            .take(1)
            .flatMap(Observable::from)
            .map(employee -> new SyncIdItem(employee.id, employee.getShortFullName(), false))
            .toList()
            .subscribeOn(Schedulers.computation())
            .observeOn(AndroidSchedulers.mainThread());
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private LessonEntry.Query getLessonQuery() {
    LessonEntry.Query.Builder builder = LessonEntry.Query.builder(mSyncId, mIsGroupSchedule)
            .subgroupFilter(mSubgroupFilter)
            .search(mSearchQuery);
    switch (mType) {
        case TODAY:
            LocalDate today = LocalDate.now();
            return builder.weekNumber(Utils.getWeekNumber(today))
                    .weekDay(today.getDayOfWeek())
                    .build();
        case TOMORROW:
            LocalDate tomorrow = LocalDate.now().plusDays(1);
            return builder.weekNumber(Utils.getWeekNumber(tomorrow))
                    .weekDay(tomorrow.getDayOfWeek())
                    .build();
        case WEEK_ONE:
        case WEEK_TWO:
        case WEEK_THREE:
        case WEEK_FOUR:
            return builder.weekNumber(mType.weekNumber()).build();
        default:
            return null;
    }
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
public void setLesson(Lesson lesson) {
    mLesson = lesson;
    mSubscription = mStorIOSQLite.get()
            .listOfObjects(Lesson.class)
            .withQuery(Query.builder()
                    .table(LessonEntry.TABLE_NAME)
                    .where(LessonEntry._ID + "= '" + mLesson.getId() + "'")
                    .build())
            .prepare()
            .createObservable()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(lessonList -> {
                if (lessonList.size() == 1) {
                    if (isViewAttached()) {
                        getView().showLessonDetail(getDetailItemList(lessonList.get(0)));
                    }
                }
            });

}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private Observable<Employee> getCacheEmployeeObservable(boolean isCached) {
    return mStorIOSQLite.get()
            .listOfObjects(Employee.class)
            .withQuery(Query.builder()
                    .table(EmployeeEntry.TABLE_NAME)
                    .where(EmployeeEntry.COL_ID + " = ?")
                    .whereArgs(mSyncId)
                    .build())
            .prepare()
            .createObservable()
            .take(1)
            .observeOn(Schedulers.io())
            .filter(employeeList -> !employeeList.isEmpty())
            .map(employeeList -> employeeList.get(0))
            .doOnNext(employee -> {
                employee.isCached = isCached;
                mStorIOSQLite.put().object(employee).prepare().executeAsBlocking();
            });
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private Observable<StudentGroup> getCacheGroupObservable(boolean isCached) {
    return mStorIOSQLite.get()
            .listOfObjects(StudentGroup.class)
            .withQuery(Query.builder()
                    .table(StudentGroupEntry.TABLE_NAME)
                    .where(StudentGroupEntry.COL_ID + " = ?")
                    .whereArgs(mSyncId)
                    .build())
            .prepare()
            .createObservable()
            .take(1)
            .observeOn(Schedulers.io())
            .filter(studentGroupList -> !studentGroupList.isEmpty())
            .map(studentGroupList -> studentGroupList.get(0))
            .doOnNext(studentGroup -> {
                studentGroup.isCached = isCached;
                mStorIOSQLite.put().object(studentGroup).prepare().executeAsBlocking();
            });
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
private void changeSyncId(Preference<String> syncIdPreference,
    Preference<Boolean> isGroupSchedulePreference) {
  Boolean b = isGroupSchedulePreference.get();
  if (b != null && b) {
    List<StudentGroup> groups = mStorIOSQLite.get()
        .listOfObjects(StudentGroup.class)
        .withQuery(Query.builder()
            .table(StudentGroupEntry.TABLE_NAME)
            .where(StudentGroupEntry.COL_NAME + " = ?")
            .whereArgs(syncIdPreference.get())
            .build())
        .prepare()
        .executeAsBlocking();
    if (groups.size() == 1) {
      syncIdPreference.set(String.valueOf(groups.get(0).id));
    }
  }
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@Override public void onCreate() {
  LocalDate date = mIsToday ? LocalDate.now() : LocalDate.now().plusDays(1);
  Utils.unsubscribe(mSubscription);
  mSubscription = mStorIOSQLite.get()
      .listOfObjects(Lesson.class)
      .withQuery(Query.builder()
          .table(LessonEntry.TABLE_NAME)
          .where(
              LessonEntry.Query.builder(mSyncIdItem.getSyncId(), mSyncIdItem.isGroupSchedule())
                  .weekNumber(Utils.getWeekNumber(date))
                  .weekDay(date.getDayOfWeek())
                  .subgroupFilter(mSubgroupFilter)
                  .build()
                  .toString())
          .build())
      .prepare()
      .createObservable()
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(lessonList -> {
        mLessonList = lessonList;
        AppWidgetScheduleProvider.updateNote(mContext);
      });
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@Override protected void onHandleWork(@NonNull Intent intent) {
  // Get lesson list for current day
  if (mFavoriteSyncIdPreference.get() != null) {
    DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
    Query query = Query.builder()
        .table(LessonEntry.TABLE_NAME)
        .where(LessonEntry.Query.builder(mFavoriteSyncIdPreference.get(),
            mFavoriteIsGroupSchedule.get())
            .weekDay(dayOfWeek)
            .subgroupFilter(mSubgroupFilterPreference.get())
            .weekNumber(Utils.getCurrentWeekNumber())
            .build()
            .toString())
        .build();
    List<Lesson> lessonList = mStorIOSQLite.get()
        .listOfObjects(Lesson.class)
        .withQuery(query)
        .prepare()
        .executeAsBlocking();
    if (!lessonList.isEmpty()) {
      showNotification(lessonList);
    }
  }
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@Override
public Map<String, String> getAll() {
    List<ScriptStaticsRecord> records = mStorIOSQLite.get()
            .listOfObjects(ScriptStaticsRecord.class)
            .withQuery(Query.builder()
                    .table(TABLE_NAME)
                    .orderBy("times")
                    .build())
            .prepare()
            .executeAsBlocking();
    return toMap(records);
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@Override
public Map<String, String> getMax(int size) {
    List<ScriptStaticsRecord> records = mStorIOSQLite.get()
            .listOfObjects(ScriptStaticsRecord.class)
            .withQuery(Query.builder()
                    .table(TABLE_NAME)
                    .orderBy("times DESC")
                    .limit(size)
                    .build())
            .prepare()
            .executeAsBlocking();
    return toMap(records);
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
public static Query QUERY_BY_ID(int id) {
    return Query.builder()
            .table(TranslatePhraseTableMeta.TABLE_NAME)
            .where(TranslatePhraseTableMeta.COLUMN_ID + " = ?")
            .whereArgs(id)
            .build();
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
public static Query QUERY_BY_PRIMARY_AND_LANG(String lang, String text) {
    return Query.builder()
            .table(TranslatePhraseTableMeta.TABLE_NAME)
            .where(TranslatePhraseTableMeta.COLUMN_LANG + " = ? AND "
                    + TranslatePhraseTableMeta.COLUMN_PRIMARY_TEXT + " = ?")
            .whereArgs(lang, text)
            .build();
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
public static Observable<StockUpdate> createLocalDbStockUpdateRetrievalObservable(Context context) {
    return v2(StorIOFactory.get(context)
            .get()
            .listOfObjects(StockUpdate.class)
            .withQuery(Query.builder()
                    .table(StockUpdateTable.TABLE)
                    .orderBy("date DESC")
                    .limit(50)
                    .build())
            .prepare()
            .asRxObservable())
            .take(1)
            .flatMap(Observable::fromIterable);
}
 

import com.pushtorefresh.storio.sqlite.queries.Query; //导入依赖的package包/类
@RxLogObservable
public Observable<User> getUser(long id) {
    return storIOSQLite
            .get()
            .object(User.class)
            .withQuery(Query.builder()
                    .table(UsersTable.TABLE)
                    .where("_id = ?")
                    .whereArgs(id)
                    .build()
            )
            .prepare()
            .asRxObservable();
}