Optionally map a SqlBrite.Query to an Observable

[AlecKazakova]

No description provided.

[JakeWharton]

I was thinking about this on the plane today, what if we return a subclass of Observable (say, QueryObservable) which exposes a <T> Observable<T> mapToModel(Func1<Cursor, T> funky) method. Your code then becomes:

db.createQuery("SELECT * FROM users", "users")
  .mapToModel(User.MAP)
  .toList()
  .subscribe(adapter);

[AlecKazakova]

Not sure that will work - toList() requires a onComplete that it's never going to get. All the logic needs to live inside a flatMap (I think). I like the idea of having something exposed at the observable level though

[JakeWharton]

Ah, right. Well it can just be

db.createQuery("SELECT * FROM users", "users") // Observable<Cursor>
  .mapToModel(User.MAP) // Observable<List<User>>
  .subscribe(adapter);

then.

[JakeWharton]

public <T> Observable<List<T>> mapToModel(final Func1<Cursor, T> func) {
  return lift(new Observable.Operator<List<T>, Query>() {
    @Override public Subscriber<? super Query> call(final Subscriber<? super List<T>> subscriber) {
      return new Subscriber<Query>(subscriber) {
        @Override public void onNext(Query query) {
          Cursor cursor = query.run();
          List<T> items;
          try {
            items = new ArrayList<>(cursor.getCount());
            while (cursor.moveToNext()) {
              items.add(func.call(cursor));
            }
          } finally {
            cursor.close();
          }
          subscriber.onNext(items);
        }

        @Override public void onCompleted() {
          subscriber.onCompleted();
        }

        @Override public void onError(Throwable e) {
          subscriber.onError(e);
        }
      };
    }
  });
}

[artem-zinnatullin]

while (cursor.moveToNext()) -> while (cursor.moveToNext() && !subscriber.isUnsubscribed())

[AlecKazakova]

By going straight into the list it's removing a lot of potential functionality that this whole PR was intended to help add. Some examples:

db.createQuery(User.TABLE_NAME, "SELECT * FROM user")
  .flatMap(query -> query.map(User.MAP)
    .filter(user -> user instanceof CoolUser)
    .toList())
  .subscribe(adapter);

db.createQuery(User.TABLE_NAME, "SELECT * FROM user")
  .flatMap(query -> query.map(User.MAP)
    .toSortedList((lhs, rhs) -> (lhs.firstName.compateTo(rhs.firstName))
  .subscribe(adapter);

Or say you want to collect the users into a set, turn them into a map/multimap, etc. They're all possible with mapToModel by doing something like

db.createQuery(User.TABLE_NAME, "SELECT * FROM user")
  .mapToModel(User.MAP)
  .flatMap(list -> Observable.from(list)
    ...
    .toList())
  .subscribe(adapter);

but I think we should be helping out the other case. Plus then we're not composing a list, splitting it out, and composing it back together again.

[JakeWharton]

Ah, right right. The conversation is coming back to me now.

[JakeWharton]

We should still do a mapToList similar to what I posted in a follow-up because the examples in the sample app are going to be the 99% case and right now they're boilerplate.

[JakeWharton]

Call this outside the try so if close() throws it'll go to onError

[AlecKazakova]

Yup definitely. Plus since they're taking the same Func1<Cursor, T> then people can use the two API's interchangeably which is nice.

[JakeWharton]

final

[JakeWharton]

I don't know how I feel about overloading map... Maybe "asRows" or "toRows" or something?

[AlecKazakova]

makes sense, map makes it sound like you're mapping the whole query to something. asRows sounds good.

[JakeWharton]

LGTM