I see that sqlbrite opens transaction using beginTransactionWithListener() which as you may know starts the transaction in EXCLUSIVE mode. I was wondering why you don't use beginTransactionWithListenerNonExclusive() which makes it possible for read operations to be performed concurrently alongside a write.

Nobody wants to work with a Query and Cursor. Add support for mapping rows to objects. This should support both table-based and custom view-based objects.

• Maven groupId is now com.squareup.sqlbrite2.
• Package name is now com.squareup.sqlbrite2.
• Query.mapTo* methods now return ObserverOperator instead of Function for use with lift instead of to.
• Backpressure is no longer supported and must be applied with operators.

Closes #136

On App-Startup i query the db and update a view on result. At the same time i do get new entries from a webservice - those are written in the db with a transaction (i'm using a contenresolver here, so i already have overridden the applyBatch method to use transactions, as it seems, it's not done per default)

    public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) {
        ...
        db.beginTransaction();
        try {
            for (ContentProviderOperation operation : operations) {
                result[i++] = operation.apply(this, result, i);
            }

            db.setTransactionSuccessful();
        } catch (OperationApplicationException e) {
            Log.d(TAG, "batch failed: " + e.getLocalizedMessage());
        } finally {
            db.endTransaction();
        }

        return result;
    }

Problem is, that the observable is triggered for every db action, alltough i perform them inside a transaction.

How do i achieve only one update of the observable?

So i created a class called CursorListAdapter that extends from AbstractList and uses a Cursor as it's backing:

public class CursorListAdapter<T>
        extends AbstractList<T> {

    private Cursor cursor;
    private Func1<Cursor, T> mapper;

    public CursorListAdapter(Func1<Cursor, T> mapper) {
        this.mapper = mapper;
    }

    public CursorListAdapter(Cursor cursor, Func1<Cursor, T> mapper) {
        this.cursor = cursor;
        this.mapper = mapper;
    }

    public void setCursor(Cursor cursor) {
        this.cursor = cursor;
    }

    public synchronized void closeCursor() {
        if (cursor!=null && !cursor.isClosed()) {
            this.cursor.close();;
        }
    }

    public Cursor getCursor() {
        return this.cursor;
    }

    @Override
    public T get(int location) {
        if (cursor==null) {
            throw new IndexOutOfBoundsException("cursor is null");
        } else if (cursor.isClosed()) {
            throw new IndexOutOfBoundsException("cursor is closed");
        }
        if (!cursor.moveToPosition(location)) {
            throw new IndexOutOfBoundsException("moveToPosition failed");
        }
        return mapper.call(cursor);
    }

    @Override
    public int size() {
        return cursor!=null && !cursor.isClosed()
                ? cursor.getCount()
                : 0;
    }
}

and then i created an Observable.Operator to lift(...) Observable<SqlBrite.Query>s into an Observable of the given type:

public class CursorListAdapterOperator<T>
    implements Observable.Operator<List<T>, SqlBrite.Query> {

    private final Func1<Cursor, T> mapper;

    public CursorListAdapterOperator(Func1<Cursor, T> mapper) {
        this.mapper = mapper;
    }

    @Override
    public Subscriber<? super SqlBrite.Query> call(final Subscriber<? super List<T>> subscriber) {
        return new Subscriber<SqlBrite.Query>(subscriber) {

            final CursorListAdapter<T> list = new CursorListAdapter<>(mapper);

            @Override
            public void onNext(SqlBrite.Query query) {
                try {
                    list.closeCursor();
                    list.setCursor(query.run());
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext(list);
                    }
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    onError(OnErrorThrowable.addValueAsLastCause(e, query.toString()));
                }
            }

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

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

I see a StrictMode warning in my console about not calling close on the cursor and I'm wondering if that's something i need to worry about or not. Here's the warning:

    flipagram E/StrictMode: A resource was acquired at attached stack trace but never released. See java.io.Closeable for information on avoiding resource leaks.
    java.lang.Throwable: Explicit termination method 'close' not called
       at dalvik.system.CloseGuard.open(CloseGuard.java:180)
       at android.content.ContentResolver$CursorWrapperInner.<init>(ContentResolver.java:2507)
       at android.content.ContentResolver.query(ContentResolver.java:515)
       at android.content.ContentResolver.query(ContentResolver.java:434)
       at com.squareup.sqlbrite.BriteContentResolver$1.run(BriteContentResolver.java:83)
       at XXXX.CursorListAdapterOperator$1.onNext(CursorListAdapterOperator.java:41)
       at XXXX.CursorListAdapterOperator$1.onNext(CursorListAdapterOperator.java:32)
       at com.squareup.sqlbrite.BackpressureBufferLastOperator$BufferLastSubscriber.onNext(BackpressureBufferLastOperator.java:101)

I'm relatively new to RxJava and SqlBrite - but my Operator should be properly closing the Cursor right?

As it stands now, a Observable<Query> emits a new query object for every change in the table, even if the corresponding rows of the query haven't changed.

It would be great if means of further filtering the notifications were added to avoid these unnecessary updates (and database queries).

Maybe something like tags for queries and updates/inserts/deletes:

// Tag the query with a string
Observable<Query> users = db.createQuery("users", "tag", "SELECT * FROM users WHERE company=?", "Square");
// This observable would now only be refreshed with database updates that are tagged with "tag"

// Tag an insert with the same tag
db.insert("users", createUser("jw", "Jake Wharton", "Square"), "tag"); // users gets notified

db.insert("users", createUser("lp", "Larry Page", "Google")); // the tag is optional, users wouldn't get notified

I have created a getContentQuery(int catId) method which return Observable<SqlBrite.Query> . Problem is that when I called mDataManager.getContentQuery(catId).subscribe() then call(SqlBrite.Query query) of Action1 inside .subscribe() executes multiple times. I used .doOnNext(new Action1<SqlBrite.Query>() this also called multiples times.

Sorry about the cryptic title. The issue is better expressed with some code and an explanation.

I'm creating an Observable for listening to sms messages, specifically I care about sent messages.

Observable<SqlBrite.Query> query = resolver.createQuery(Uri.parse("content://sms/"), null, null, null, null, true);

subscription = query
    // Ignore first immediately emitted value
  .skip(1)
    // read the query, output Message object, which has data from the cursor
  .flatMap(…) 
    // filter everything except sent messages
  .filter(…)
    // Only unique messages
  .distinct(…)
    // We only care about certain keyword in the message
  .filter(…)
    // Show a dialog box
  .compose(…)
    // Filter out if user canceled dialog
  .filter(…)
  .subscribeOn(Schedulers.io())
  .observeOn(scheduler)
  .subscribe(…);

Even after filtering on "sent" I'll get about 5 or 6 Messageobjects per actual sent sms message. When I first push a build to my phone, everything works as expected. Some unknown time later (I usually notice the next day) two identical Message objects pass distinct(). Specifically the first two.

Message has correctly implemented equals() and hashCode().

This may or may not be an issue with SqlBrite but I've been battling this for a while so I'm exploring all of my options. (I have a similar message out on the RxJava mailing list).

https://github.com/square/sqlbrite/issues/58

This is my first lint check so I am not sure if I've covered all the cases. I was using Timber lint checks as a reference. I'll appreciate any feedback!

I'm not able to use Observable.concat() with SqlBrite to concatenate few observables. So, after SqlBrite returned some result the other observables is not called. For example, in this case I always get null from localSource and noting else:

return Observable.concat(localSource, remoteSource).first();

In this case localSource returns null (since there is no data, e.g. first application launch) and after that code execution stops in first filter check:

return Observable.concat(localSource, remoteSource)
        .filter(new Func1<Item, Boolean>() {
            @Override
            public Boolean call(Item item) {
                return item!= null;
            }
        });

For fetch data from db using next code:

@Override
public Observable<Item> get(String id) {
    //creating sql query

    return databaseHelper.createQuery(ItemEntry.TABLE_NAME, sqlQuery, id)
        .mapToOneOrDefault(mapperFunction, null);
}

Could there be some investigation and perhaps implementation of a mechanic to allow for switching between Android's default SQLite engine or one issued by Requery?

@JakeWharton have you given this any thought?

When running Lint on a project that uses SqlBrite 3.2.0:

Warning: Lint found an issue registry (com.squareup.sqlbrite3.BriteIssueRegistry) which did not specify the Lint API version it was compiled with.

This means that the lint checks are likely not compatible.

If you are the author of this lint check, make your lint IssueRegistry class contain   override val api: Int = com.android.tools.lint.detector.api.CURRENT_API or from Java,   @Override public int getApi() { return com.android.tools.lint.detector.api.ApiKt.CURRENT_API; }

If you are just using lint checks from a third party library you have no control over, you can disable these lint checks (if they misbehave) like this:

    android {         lintOptions {             disable "SqlBriteArgCount"         }     } [ObsoleteLintCustomCheck] Applies to variants: debug

Explanation for issues of type "ObsoleteLintCustomCheck": Lint can be extended with "custom checks": additional checks implemented by developers and libraries to for example enforce specific API usages required by a library or a company coding style guideline.

The Lint APIs are not yet stable, so these checks may either cause a performance, degradation, or stop working, or provide wrong results.

This warning flags custom lint checks that are found to be using obsolete APIs and will need to be updated to run in the current lint environment. It may also flag issues found to be using a newer version of the API, meaning that you need to use a newer version of lint (or Android Studio or Gradle plugin etc) to work with these checks.

Unfortunately, disabling 'SqlBriteArgCount' as shown above results in the following error:

Error: Unknown issue id "SqlBriteArgCount" [LintError] disable "SqlBriteArgCount"

Add a method Observable<List<String>> observeTables(String... tables) or similar to BriteDatabase, that notifies observers with a set of affected tables, but does not create any query.

Scenario: We sync cats and dogs stored on our backend, and persist them using a transaction.(pseudo-code, cursor/cv mapping omitted)

try (Transaction transaction = database.newTransaction()) {
    for(Cat cat: cats) {
        database.insert("cat", cat);
    }
    for(Dog dog: dogs) {
        database.insert("dog", dog);
    }
    transaction.markSuccessful();
}

We fetch all cats and dogs when initializing our view. (In real code in a background thread, obviously)

List cats = database.query("SELECT * FROM cat");
List dogs = database.query("SELECT * FROM dog");
catAndDogView.setCatsAndDogs(cats, dogs);

How do I make this reactive?

Observable<List> cats = database.createQuery("cat", "SELECT * FROM cat");
Observable<List> dogs = database.createQuery("dog", "SELECT * FROM dog");
Observable.combineLatest(cats, dogs, (cats, dogs) -> new Object[]{cats, dogs})
    .subscribe(objects -> catAndDogView.setCatsAndDogs(objects[0], objects[1]));

This is flawed, because I'm now getting two updates per transaction. Replacing combineLatest() with zip() won't do neither, because then I'm missing out on updates that involve only cats, or only dogs. A work-around is having each query triggered by changes on either table, but that comes at the expense of running some redundant queries.

As an added benefit of my proposal, having the opportunity to react to table changes myself, would allow me to create DAOs with synchronous methods, and reusing these methods when I want to create reactive versions.

class DAO {
    List<Cat> findBlackCats(BriteDatabase database) {
        return database.query("SELECT * FROM cat WHERE color = black");
    }
}

Observable<List<Cat>> blackCats = database.observeTables("cat")
    .map(ignore -> dao.findBlackCats(database));

My proposal is based on what SquiDB seems to offer.

StrictMode is lazy and only detects slow queries on the main thread. This is mostly useless since the query execution time is subjective based on the data in the DB and CPU/disk performance of the device.

There's a few options here:

• Inform StrictMode via noteSlowCall and allow normal penalties to apply. This sucks because there's no granularity between those posting to this method and puts the subjectiveness of what's slow into the libraries. There would be no way to enable slow call penalties from one library but disable it from another. Granted, this is unlikely.
• Add our own strict mode analogous which allowed the detection of queries running on the UI thread.
• Provide a composition point for either observable creation or query object creation. This would allow someone to mix in things like main thread checking, or perhaps default schedulers.

This isn't urgent, so we have time to think about what's most appropriate.

• [ ] Creating a query inside of a transaction
• [x] Question marks in a query don't match number of arguments (#220)
• [ ] Missing mark success in try/finally or try-with-resources
• [ ] Multiple insert/update/delete statements not in a transaction in a single method
• [ ] Ensure first argument looks like a table / list of tables
• [ ] Second argument looks like SQL and contains all tables from the first argument

Reload SQLiteOpenHelper and re-query

In my app I have a import/export functionality, by importing, the SQLite database file is replaced by one on the sdcard, so I need to reload the SQLiteOpenHelper and then notify all the Queries.

Something like the following method would be really handy!

public void reloadDatabase(SQLiteOpenHelper helper, Set<String> tables){
   // Replace the SQLiteOpenHelper
   synchronized (databaseLock) {
      readableDatabase = null;
      writeableDatabase = null;
      this.helper.close();
      this.helper = helper;
   }
   // Make all Queries to reload
   sendTableTrigger(tables);
}

Or prehaps BriteDatabase can save a Set of tables, filled as we query them, to be notified on a potential database reload?

I guess I could make the user restart the app, but I rather not.

SQLBrite is amazing as it is very simple and allow us to get rid of loaders, and IMO notifying on tables is far better than the Uri system, thanks for creating SQLBrite!

Re-query only

Let's say my app is a calendar, I have an upcoming event list, starting by today's events. In every event list I want to mark each yesterday's event as missed.

Then I need to reload event's Queries every day at 00:00. In this particular case it would make sense to make the sendTableTrigger() public and call it every day.

I could also use a Observable.combineLatest with a Query and a PublishSubject and call this Subject every day to run the Query again, but since table triggers are managed the same way, it seems simple to switch sendTableTrigger() to public.

To support this idea; ContentResolver's notifyChange(Uri uri, null) is public.