IssueTracker

I'm still working on a fix, but here's the current state of OnConflictStrategy.

# REPLACE
Works as expected. Old rows are replaced.

# IGNORE
Works as expected. New rows are ignored.

# ROLLBACK
This ends the transaction on conflict. Thus, the following call of endTransaction() always fails. This is basically unusable.

# ABORT (default)
As the SQLite doc says, all the changes prior to this statement are preserved, but they are rolled back by the surrounding transaction anyway.

# FAIL
This works pretty much the same as ABORT, except that it does not roll back the current statement at first. It is, however, rolled back by the surrounding transaction along with the preceding changes.

In summary, ABORT and FAIL produce the same results, and unlike the SQLite doc says, they both roll back on conflict (because of the surrounding transaction). ROLLBACK always fails.

Yes, this is exactly what I observed. It seems that FAIL and ROLLBACK strategies don't make much sense for Room. If this is correct, maybe you should deprecate and later remove them to avoid confusion?

Fine!
Maybe it would also be useful to mention in the docs which strategies can throw an SQLiteConstraintException (btw, is it the only possible type of exception?) and which cannot.

SQLiteConstraintException is the only type thrown by the platform SQLite, but if you use custom implementation [1], it might throw something else.
[1]: https://developer.android.com/reference/android/arch/persistence/room/RoomDatabase.Builder.html#openHelperFactory(android.arch.persistence.db.SupportSQLiteOpenHelper.Factory)

Project: platform/frameworks/support
Branch: androidx-master-dev

commit b8b669fd8cc863ad19a5e6c912b163aab107a86f
Author: Yuichi Araki <yaraki@google.com>
Date:   Mon Dec 03 11:40:46 2018

    Deprecate OnConflictStrategy.ROLLBACK and FAIL
   
    OnConflictStrategy.ROLLBACK was never working properly. On conflict, it
    always fails with SQLiteException since Room tries to end the
    transaction which has already been rolled back by the conflict. In
    addition, framework has a bug in handling of transaction around ROLLBACK
    (b/120397728), so it is impossible to make this work as expected.
   
    Instead, ABORT has always worked like ROLLBACK. This is because the
    INSERT throws SQLiteConstraintException on conflict, so the wrapping
    transaction is ended without being marked as successful and thus rolled
    back. We could change this to work more like SQLite's original ABORT
    (keep preceding changes in the transaction), but it is too risky to
    change the behavior of ABORT since it is the default option of @Insert
    and @Update.  This CL just clarifies the behavior in Javadoc.
   
    OnConflictStrategy.FAIL is no different from ABORT because of the
    wrapping transaction. We should just remove it for clarity.
   
    REPLACE and IGNORE are working fine.
   
    Bug: 117266738
    Test: OnConflictStrategyTest
    Change-Id: Id62920d531afe4644d9d37ffc823a65132b54b4f

M       room/common/api/2.1.0-alpha03.txt
M       room/common/api/current.txt
M       room/common/src/main/java/androidx/room/Insert.java
M       room/common/src/main/java/androidx/room/OnConflictStrategy.java
M       room/common/src/main/java/androidx/room/Update.java
A       room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/test/OnConflictStrategyTest.java

https://android-review.googlesource.com/839274
https://goto.google.com/android-sha1/b8b669fd8cc863ad19a5e6c912b163aab107a86f

Thanks for the sample app. I haven't gotten to the bottom of the issue yet but I wanted to give you an update and it does seem indeed that Room is taking a very long time to parse and understand your queries via the ANTLR generated parser that Room uses. I'm not sure what is so special about your queries that is causing this, but I'll comment back with an update once I find out. Sadly for now I don't have a recommendation on a workaround.

Alright, I've drill down the problem to being the various "OR <col_name> LIKE '%' : text '%'" in your queries. Specifically they cause the SQLiteParser in Room to go down a path with poor performance as described in https://github.com/antlr/antlr4/issues/1398. A fix for this involves updating Room's ANTRL runtime library and generated parser code with the latest version. This update will likely be available in Room 2.1.0-alpha02.

Thanks for the update. Is 2.1.0-alpha02 around the corner?

Project: platform/frameworks/support
Branch: androidx-master-dev

commit 8e46b9ca1f55b040a18dd86833880b5106d103b2
Author: Daniel Santiago Rivera <danysantiago@google.com>
Date:   Wed Oct 10 19:17:50 2018

    Update Room's ANTLR Parser to 4.7.1
   
    Updating to the latest ANTLR version fixes the performance issue
    described in https://github.com/antlr/antlr4/issues/1398 which affects
    Room's SQL Parser since it contains left-recursive rules. Specifically
    SQLite.g4 has multiple recursions to describe an expression as defined
    in https://www.sqlite.org/lang_expr.html, meaning if a user has certain
    queries that causes the parser to use the adaptivePredict algorithm
    then the build time increases significantly due to Room's query
    parsing.
   
    Also bumped Room's version to 2.1.0-alpha02
   
    Bug: 117401230
    Test: ./gradlew room:integration-tests:testapp:cC
    Change-Id: I4d0799a11ccee816ab209cbf74e7dcf2b2ce1a18

M       buildSrc/src/main/kotlin/androidx/build/LibraryVersions.kt
M       buildSrc/src/main/kotlin/androidx/build/dependencies/Dependencies.kt
M       room/integration-tests/testapp/src/androidTest/java/androidx/room/integration/testapp/dao/UserDao.java

https://android-review.googlesource.com/786077
https://goto.google.com/android-sha1/8e46b9ca1f55b040a18dd86833880b5106d103b2

No concrete date on 2.1.0-alpha02, I want to get a few more bugs in before making the next alpha release. So maybe by the end of the month.

Thanks.

On Tue, Oct 16, 2018, 4:52 AM <buganizer-system@google.com> wrote:

--

- Ankit