Many updates!

1. NEW livedata artifact (consider it experimental). Call .toLiveData on your wrapper queries when included in the project.
2. Docs have been revamped, lots of fixes and improvements. Removed all java examples in favor of Kotlin usage
3. Gradle files now use kotlin
4. Respect order of Primary Key definition in insert statement
5. Optimize more code generation
6. RX support is bumped to RX3
7. Breaking: Index wrapper enable and disable have been replaced with their SQL accurate counterparts createIfNotExists and drop.
8. New: DBFLow configure DSL

FlowManager.init(context) { 
  // this is FlowConfig.Builder
  database<AppDatabase> {
    // this is DatabaseConfig.Builder
    table<MyTable> {
      // this is TableConfig.Builder
    }
  }
  // other module dbs
  databaseHolder<MyGeneratedDatabaseHolder>()
}

9. SQL: adds random orderby method
10. Migrations: support default values in ALTER table statement
11. Migrations: Restore pre 5.0.0-alpha1 migration order where they run after table creation in upgrade of DB.
12. Foreign Key Constraints: fix issue where foreign key constraint support not always enabled or done properly. Now we perform it in onConfigure of the DB.
13. NEW: FTS4 and FTS3 support.
14. Breaking: Require DatabaseWrapper in any db operation, removing model extension methods that are parameterless in most places. to grab DB, use database<MyDatabase> { db -> or val db = database<MyDatabase>()
15. Breaking: Breaking change: String "?" no longer are unescaped and treated as blank INSERT value args. Use Property.WILDCARD instead.
16. Model queries that do not run in a transaction now will log as warnings to encourage you to place them in transactions.
17. NEW: TableObserver provides a way to observe table changes in an efficient way for observable queries.
18. NEW: match operator for queries
19. NEW: tables can be represented without actually being created in the DB. use createWithDatabase in the @Table or @ModelView annotations.
20. Breaking: IMultiKeyCacheConverter -> MultiKeyCacheConverter
21. NEW: create TEMP tables support using @Table(temporary = true)
22. Breaking: async queries from RX asFlowable or others, instead of passing DatabaseWrapper and ModelQueriable like:

.asFlowable { d, modelQueriable -> modelQueriable.queryList(d) }

Now its the receiver parameter of the function:

.asFlowable { db -> queryList(db) }

23. OneToMany: fix issue where cache and one to many would not work when using the all operators.
24. FlowQueryList/FlowCursorList: allow passing own Handler to be used rather than the thread its created on.
25. Breaking: its an error to have multiple converters on the same model type. Error message describes how to fix.

• allow overwriting built-ins without error
• better error messaging in general with less noise

26. BaseProviderModel: fix potential leaking cursor when no results found.
27. SQLCipher: Latest version is now 4.4.2, Write ahead logging support!
28. Breaking: prepackaged dbs now can run migrations to get to current version when db version is 0 but we set our db version to something higher. This reduces errors by allowing you to keep an older version of DB as prepackaged but will run through migrations to get to current app version's DB.

Also many bug fixes! https://github.com/agrosner/DBFlow/milestone/51?closed=1

1. Rename package name for project to com.dbflow5. Some significant package reorganization that makes much more sense going forward.
2. Project is back under my account! To include, please replace uses of "com.github.raizlabs.dbflow:" to "com.github.agrosner.dbflow:" in project dependencies.
3. Added new paging, coroutines, contentprovider (splits out use into separate module). Expect a livedata module in next couple releases. Removed RXJava 1 support.
4. Library is now 100% KOTLIN! (except generated java code, which can't quite yet be Kotlin). All kotlin-extensions modules have rolled into their java counterpart as a single Kotlin unit.
5. Simplifications in API for Transactions to eliminate redundancies. Also, now Transaction require a type parameter R which is return value. They now return a value, and have a completion() callback. All interfaces have rolled into Kotlin Typealias to methods.
6. All sqlite query language infix (LINQ-style) methods rolled into the query language!
7. Attempted to keep java compatibility and nice API. If anything is missing, please file a bug.
8. save() now use a insert or replace statement rather than a load of the model from the db and then inserting / saving based on that, resulting in significant performance increase.
9. no more ContentValues used at all in any CRUD operations under the hood, and by default these don't get generated: bindToInsertValues, bindToContentValues. if you need them, set @Table(generateContentValues = true).
10. Breaking Change: By default @Table(allFields = true), meaning you dont have to explicitly mark each property as part of DB. Previously you had to use @Column everywhere.

1. dropTrigger from SqlUtils takes in a DatabaseWrapper.
2. Fix broken annotation processor code output tests. #1437
3. Fix issues where DatabaseStatement in library in wrapper statements were not closed properly. #1497
4. Fix issue where single reference (non table object) used wrong name for property in the primary condition clause, causing compile issue. #1504

1. update Issue template
2. fix pom file generation on jitpack #1487
3. fix issue where save(DatabaseWrapper) would leave open insert or update statment. #1496
4. Allow (but still warn) about autoincrementing ids being null. if null, they are treated as if they are 0 meaning that they will get inserted rather than updated in the DB during a save operation. #1490
5. Update warning on wrong type passed in operator class for value #1488

Fix critical issue where TypeConverter always appear as SQLiteType.TEXT in the DB even if its type did not match up.

Adds a test to ensure it stays true.

https://github.com/Raizlabs/DBFlow/issues/1481

Add FlowQueryList.Builder.contentAuthority() parameter to go in conjunction with 4.2.0 changes.

Support for Android O Content Providers. Simply add this line to your AndroidManifest.xml:

<provider
            android:name="com.raizlabs.android.dbflow.runtime.StubContentProvider"
            android:authorities="com.dbflow.authority"/>

Which will allow normal content observing to continue. It is highly recommended to supply your own authority: use your own package name. so for com.grosner.example app I would add:

<provider
            android:name="com.raizlabs.android.dbflow.runtime.StubContentProvider"
            android:authorities="com.grosner.example"/>

FlowManager.init(FlowConfig.Builder(context)
            .addDatabaseConfig(DatabaseConfig.Builder(MyDatabase.class)
                .modelNotifier(new ContentResolverNotifier("com.grosner.example"))
                .build()).build());

1. Autoincrement model saver does not call saveForeignKeys() #1454
2. Ability to reopen DB without deleting #1449
3. AutoIncrementModelSaver causes IllegalArgumentException since it uses wrong insert statement #1447
4. Disallow nullable autoincrementing fields. (kotlin nullable (?) and @Nullable annotations)
5. Can close all DBs at runtime. #1418
6. fix support for byte[], class was incorrectly treated as invalid array type. #1463
7. Compiled with Kotlin 1.1.51, 26.0.2 of Android build-tools, and 3.0.0-rc2 of Android Gradle plugin.

1. Fix issue with ByteArray and TypeConverter #1385
2. Fix issue where processor used implementation. switched back to compile.

1. @ModelView are now created after migrations are run so latest DB data is respected.
2. New annotation @ColumnMap! It enables embedding other object's exposed properties into the current table as @Column so that object hierarchy is respected without excessive DB complication.

class Location(var latitude: Double = 0.0, var longitude: Double = 0.0)

@Table(database = TestDatabase::class)
class Position(@PrimaryKey var id: Int = 0, @ColumnMap var location: Location? = null)

creates a table with the following columns:

  public static final Property<Integer> id = new Property<Integer>(Position.class, "id");
  public static final Property<Double> latitude = new Property<Double>(Position.class, "latitude");
  public static final Property<Double> longitude = new Property<Double>(Position.class, "longitude");

3. @Database(name = , extension = ) are deprecated. Specify the name now in the DatabaseConfig.databaseName() when FlowManager is initialized. This means that DBFlow supports dynamic database names and instances.

FlowManager.init(FlowConfig.builder()
    .addDatabaseConfig(DatabaseConfig.builder(AppDatabase.class)
      .databaseName("AppDatabase")
      .databaseExtension(".txt")
      .build())
    .build())

To dynamically swap database out, replace the FlowConfig:

FlowManager.getDatabase(AppDatabase.class)
  .reset(DatabaseConfig.builder(AppDatabase.class)
    .databaseName("AppDatabase-2")
    .build())

Note that this will overwrite all existing database properties for a database. Any TableConfig properties missing will get ignored. Also it will delete existing db and reopen with new instance specified.

4. @Database(inMemory = ) is deprecated. Use the new builder method:

FlowManager.init(FlowConfig.builder()
    .addDatabaseConfig(DatabaseConfig.inMemoryBuilder(AppDatabase.class)
      .databaseName("AppDatabase")
      .build())
    .build())

5. Support javax.annotation.Generated if it's on the classpath.
6. @Database(generatedClassSeparator = ) is now deprecated. It will be standardized to the default _ in a future breaking release.
7. @OneToMany now auto-detect visibility of the reference field so isVariablePrivate() is deprecated.
8. Can specify @ForeignKeyReference(notNull = @NotNull()) annotation for individual references. Required to specify all references on a @ForeignKey if you need to specify for one.
9. Some better error messaging in the annotation processor so its easier to find solutions to common issues.
10. Rename count() (deprecated) to longValue() so its more clear exactly what is happening.
11. fix #1401 which enables custom TypeConverters to carry into an as() alias of a Property.
12. Add new TransactionWrapper which allows grouping of ITransaction into one to get executed at same point in db time.
13. Lib now compiles with SDK 26 with latest build tools including api/implementation of 3.0.0+ gradle plugin.
14. RXJava2 is now updated to 2.1.3
15. Update some methods of dbflow-kotlin-extensions to accept nullable values for objects where it makes sense. See commit
16. Automatic creation of tables can be turned off on a table-by-table basis with createWithDatabase(). Useful for preserving scrapped table in previous migrations.
17. Using Kotlin we can drastically reduce the @OneToMany code implementation:

    @OneToMany(methods = {OneToMany.Method.ALL}, variableName = "ants")
    public List<Ant> getMyAnts() {
        if (ants == null || ants.isEmpty()) {
            ants = SQLite.select()
                .from(Ant.class)
                .where(Ant_Table.queen_id.eq(id))
                .queryList();
        }
        return ants;
    }

to:

@get:OneToMany(methods = arrayOf(OneToMany.Method.ALL))
var ants by oneToMany { select from Ant::class where (Ant_Table.queen_id.eq(id)) }

1. Move the GeneratedDatabaseHolder off the last round, warnings should be gone!
2. Update Kotlin to 1.1.3-2
3. update Gradle plugin to 2.3.3 (3.0.0-beta currently breaks robolectric unit testing)
4. Some new extensions
5. add Property.allProperty(MyTable.class) so you can easily specify MyTable.* in a query.
6. Some optimizations on generated code including removing some redundant null checking.
7. Fix issue where DatabaseStatement in update were not closed when used in a ModelAdapter.saveAll() method.
8. Fix package private ModelView that duplicated field definitions in generated _ViewTable class.
9. RXJava2: Change Single to Maybe for nullable returns.

1. Even better Kotlin support. if a field is not null in Kotlin or using the android.support.annotation.NonNull/org.jetbrains.annotations.NotNull annotation, we will not attempt to assign a null value on it when the Cursor contains a null value. Primitives always did this of course, but now its expanded to any time.
2. Fixed a bug by throwing a compiler error if you reference another class in another package that has package private fields, yet its not annotated with @Table, @ModelView, or @QueryModel. You must make it public or getter/setter private.
3. Fix nullable Float fields not compiling.
4. Add BigIntegerConverter to the lib!
5. Fix issue where primary keys of a reference@PrimaryKey has the same name as the calling table, i.e. both having id as a column name in the generated ModelAdapter code.
6. Fix issue where generated @ManyToMany referenced tables that had primary keys with TypeConverter not properly calling typeconverter, leading to compile errors.
7. Fix issue where a table with cachingEnabled=true with a stubbedRelationship table where the object that calls load called the same instance from the cache (effectively not doing anything), and did not reload its fields from the DB.
8. More bug fixes + improvements.

1. Fix issue with notIn with BaseModelQueriable parameters
2. Enhanced Kotlin support by annotation almost all of public api with @Nullable and @NonNull
3. Fix bug with @ManyToMany generated class not properly handling type converters.
4. A couple more bug fixes.

1. Fix issue where enums broke the processor. #enumsmatter
2. Replace ContentValues with DatabaseStatement for updating models, this results in a 33%-50% speed increase!
3. More @NonNull and @Nullable annotations
4. Delete queries also use generated DatabaseStatement, speeding up bulk deletes.
5. Add notnull to @InteritedColumn annotations.
6. RXJava observeOnTableChanges() updates. each ModelNotifier has common interface for interaction.
7. ModelChangeListener for DirectModelNotifier now uses OnTableChangeListener.onTableChanged() which adds a Class for which table changed. This enables better consolidation of interfaces. OnTableChangedListener promoted to top-level interface.

1. Fixes issue with new documentation website, Gitbooks, and permissions.

Major new release. Some of the major changes:

1. Code generation significantly reduced. more than ~40% reduction in lines of code. Also order is deterministic and always the same in output.
2. Condition -> Operator including ConditionGroup -> OperatorGroup
3. Rewrote a lot of annotation processor with KPoet and now 99% Kotlin!
4. Much better Kotlin support via @NonNull and @Nullable annotations on most public api methods.
5. Can supply a different way to notify observers of changes via the new DirectModelNotifier or legacy ContentResolverNotifier
6. Remove Model restriction from the library. Classes no longer need to implement Model. Kotlin consumers can take advantage of extension methods in kotlin-extensions to make classes act like Model.
7. Latest plugins + Kotlin 1.1.2
8. PrimaryKey can have type converters.
9. ForeignKeyContainer is replaced with @ForeignKey(stubbedRelationship = true). Use Model.load() to get same functionality as before, without the confusion! 10 . Removed ModelContainer implementation and support. Since removing support, the annotation processor is cleaner and easier to maintain.
10. Added RXJava1 + 2 support via sub-packages, with corresponding Kotlin extension libraries.
11. New documentation website here
12. Bug fixes, documentation updates, and more.

Fixes issue where the rx, rx2, and corresponding Kotlin extensions for each did not publish to JitPack.

This should be last beta before 4.0.0 if no serious issues.

1. rewrite unit tests - most classes are tested. more tests will follow
2. Condition are now Operator, this includes SQLCondition -> SQLOperator, ConditionGroup -> OperatorGroup. Operator are now typed and safer to use. -> Operator now also have div, times, rem, plus and minus methods.
3. Property class changes: -> All primitive Property classes have been removed. We already boxed the values internally anyways so removing them cut down on method count and maintenance. -> BaseProperty no longer needs to exist, so all of it's methods now exist in Property -> mod method is now rem (remainder) method to match Kotlin 1.1's changes. -> dividedBy is now div to match Kotlin operators. -> multipliedBy is now times to match Kotlin operators.
4. Add KPoet to Annotation processor to make processing code more readable.
5. Many More Kotlin extension methods
6. Code output is deterministic, meaning always in same order unless generated files are added or removed.
7. Reduce code generation further in this branch.
8. Add a bunch of @Nullable and @NonNull annotations to public api members to better support Kotlin.
9. Abstracted out the default Model notification system to allow you to override how its done. the options include ContentResolverNotifier (default, previous implementation wrapped in new), or DirectModelNotifier - receive changes with the Model directly.

Attempt to republish beta4.

1. Close insert SQLiteStatement from ModelAdapter when resetting DB.
2. @QueryModel + @ModelView no longer require their BaseQueryModel + BaseModelView base classes.
3. Added ability to specify allowedSubTypes in TypeConverter, meaning subclasses of types can all register to same typeconverter.
4. Allow user override of default TypeConverters by declaring usual custom converter with the @TypeConverter annotation.
5. Cut libs method count footprint by ~100. Library now stands at 2278 methods. Also cut down on generated code + generated code method references when some method overrides were generated even when not actually used for custom behavior in ModelAdapter.
6. Methods Added: Add nullIf() and ifNull() methods. Support strftime(), date(), and datetime() methods.
7. Can now disable caching for models with caching enabled in certain queries via:

select().from(MyTable.class)
.disableCaching()
.queryList()

1. save, delete, + update methods in Model + ModelAdapter all return boolean for success / failure.
2. Can specify custom db extension via @Database(databaseExtension = ) 10 .ProcessModel interface method now adds a DatabaseWrapper: processModel(Model, DatabaseWrapper
3. Can do async insert, update, and delete via:

insert(MyTable.class)
.columns(...)
.values(...)
.async()
.execute()

1. Minor bug fixes + code stability improvements.

1. Rewrote most tests in full Kotlin
2. Some bug fixes
3. Update to 1.5.0-2 of Kotlin
4. Update to compile with API 25 + 2.2.3 of Gradle plugin
5. Simplified ForeignKeyReference annotation when specifying it in the @ForeignKey. Removed : columnType(), referencedFieldIsPrivate(), referencedFieldIsPackagePrivate(), referencedGetterName(), and referencedSetterName() since we already were grabbing the referenced definition in the processor. This will eliminate need for those fields and should make simple headaches go away!
6. If DB gets closed, we reopen it next time we use it in the lib.
7. Add Selection args to StringQuery
8. Fixed an issue where multiple modules may have been broken.

1. Upgrade to API 25 (7.1.1)
2. @Column with TypeConverter now properly convert specified Model types in SQLite queries via the generated TypeConvertedProperty class! Also you can reverse the query to specify the Database-typed query in a SQLite query:

Coordinate coord = ...;
SQLite.select().from(MyTable.class).
  .where(MyTable_Table.coordinate.eq(coord))
  .querySingle();

or

Latitude lat = ...;
SQLite.select().from(MyTable.class).
  .where(MyTable_Table.coordinate.invertProperty().eq("40.707720, -74.014842"))
  .querySingle();

1. Add BigDecimalConverter as default converted included in lib.
2. Fix issue with private field access in a @ForeignKey reference, due to new processor code.
3. More bug fixes.
4. Remove type param from BaseModelView, no longer necessary or needed.
5. Fixes issue where Enum were not properly converted.

In 4.0, DBFlow has greatly improved its internals and flexibility in this release. We have removed the Model restriction, rewritten the annotation processor completely in Kotlin, and more awesome improvements.

Major Changes In this release

1. PrimaryKey can have TypeConverters, be table-based objects, and all kinds of objects. No real restrictions.
2. ForeignKey have been revamped to allow stubbedRelationship. This replaces ForeignKeyContainer.
3. Model interface now includes load() to enabled reloading very easily when fields change.
4. All ModelContainer implementation + support has been removed. A few reasons pushed the removal, including implementation. Since removing support, the annotation processor is cleaner, easier to maintain, and more streamlined. Also the support for it was not up to par, and by removing it, we can focus on improving the quality of the other features.
5. The annotation processor has been rewritten in Kotlin! By doing so, we reduced the code by ~13%.
6. Removed the Model restriction on tables. If you leave out extending BaseModel, you must interact with the ModelAdapter.
7. We generate ~45% less code than 3.0. Combined the _Table + _Adapter into the singular _Table class, which contains both Property + all of the regular ModelAdapter methods. To ease the transition to 4.0, it is named _Table but extends ModelAdapter. So most use cases / interactions will not break.

Fix issue where project did not build on jitpack.io due to javadoc issues.

Transaction Handler only initialized when used, not when class first accessed to prevent unnecessary Handler thread from starting. Also Transaction now have a newBuilder() method to allow easy copying of existing Transaction.

1. Bug fixes
2. Fixes an issue where prepackaged databases were not copied over on initialization of DB. #867. Affects all versions post-3.0.0-beta6.
3. New builder syntax for FlowQueryList + FlowCursorList. Deprecated a lot of their old methods. Also created a FlowCursorIterator so that iteration in FlowCursorList + FlowQueryList becomes way more efficient. Instead of loading the full list when iterating, it iterates and converts objects as you need them:

for (TestModel model : cursorList) {

}

1. Can add primaryKeyConflict to @Table to optionally specify a conflict for a Primary key that gets appended to the creation query.
2. NEW Kotlin SQLite LINQ-Style Syntax and improvements to the Kotlin Support. In dbflow-kotlinextensions you can now write queries in Kotlin as:

var results = (select
                      from Result::class
                      where (column eq 6)
                      and (column2 `in`("5", "6", "9"))
                      groupBy column).list
              // can call .result for single result
              // .hasData if it has results
              // .statement for a compiled statement

Some new syntactic sugar that makes queries even more functional:

model.async save {
  // completed, now do something with model
}

Retrievals:

(select
    from Result::class
    where (column eq 6))
 .async result { transaction, model ->
    // do something here
    updateUI(model)
}

for Lists:

// easy async list query
(select
    from Result::class
    where (column eq 6))
.async list { transaction, list ->
    // do something here
    updateUI(list)
}

1. Fixes issue where AsyncModel operations did not actually operate on its associated Model.
2. Fix code gen for overridden Update, Insert, delete ops where passing in DatabaseWrapper did not honor @OneToMany annotation.
3. Fix issue where ListModelSaver ignores caching rules.

This release incorporates a host and slew of improvements. A large chunk of the library has been rewritten, reworked, and improved significantly.
New Features

1. Properties: Instead of generated column String names, Property simplify queries even further and provide type-safety.
2. Transactions Rewritten: Transactions have been rewritten from the ground-up to provide flexibility, better syntax, and easy customization. You can even swap out the library's system and replace it with your own.
3. Database Encryption Support: via SQLCipher enables secure databases with minimal configuration and effort in DBFlow!
4. Usage Docs: I rewrote usage docs to be more comprehensive and informative.
5. Foreign Keys Simplified: no longer do you have to manually specify @ForeignKey references.
6. Caching with Multiple Primary Keys: Caching now supports multiple primary keys and keys of any supported type.
7. Database Modules: DBFlow is supported in multiple application projects via modules. This enables sharing of Databases and their associated files.
8. Better Code Generation: Support package private fields from different packages, better error messaging during compile phase, significant code gen improvements, and more.
9. Kotlin Extensions Support: Via dbflow-kotlinextensions allows you to write better DBFlow code in Kotlin.
10. New SQLite features supported such as Case, CAST, and more!
11. Many bug fixes, code comment improvements, code generation improvements, and more.

To read on the basic migration steps, read here

Ideally this will be the final beta before 3.0 goes live. The next release should incorporate any more bugs or issues found in 3.0, so keep reporting!

This release contains three significant updates:

1. Initialization of DBFlow has changed. Now configuration of ModelAdapter, @Database, and other classes can mostly be done through the new FlowConfig.Builder class. For a simple example, view an example here
2. The transactions system got a complete and utter overhaul. Welcome the Transaction.Builder! Each Transaction contains Success and Error callbacks for easy listening. See the migration guide for guidance. By default, we no longer use a priority-based queue for transactions. To keep that, read here. You can now also specify and roll your own ITransactionQueue or BaseTransactionManager, read up here.
3. I rewrote the documentation completely for accuracy and for better organization. I hope you like!

Some new features:

1. Can now use the CASE Operator! `SQLite.

SQLite.select(CaseModel_Table.customerId,
                CaseModel_Table.firstName,
                CaseModel_Table.lastName,
                SQLite.caseWhen(CaseModel_Table.country.eq("USA"))
                        .then("Domestic")
                        ._else("Foreign").end("CustomerGroup")).from(CaseModel.class);

1. Can Collate.LOCALIZED and Collate.UNICODE
2. Can now multipliedBy(), add(), dividedBy(), mod(), and concatenate() IProperty together.
3. This release contains a number of bug fixes as well here](https://github.com/Raizlabs/DBFlow/issues?q=milestone%3A3.0.0-beta6+is%3Aclosed)

1. Fixes a critical issue where some queries (those that end off at Where) count()/hasData() when run with empty table throws a SQLiteDoneException on the query. now suppresses exception and logs it.
2. can now pass in DatabaseWrapper into any saving methods of a ModelAdapter in order to better work in migrations! So that we do not recursively call the SQLiteDatabaseObject. So now all CRUD operations are supported in DBFlow migrations:

ModelAdapter modelAdapter = FlowManager.getModelAdapter(SomeTable.class);

modelAdapter.save(wrapper, someModel);


modelAdapter.insert(wrapper, someModel); 

This release contains a few major updates.

1. All unit tests are now run in JVM via Robolectric
2. @ForeignKey now saveForeignKeyModel=false by default, since this can lead to errors or unexplained performance hits. Rather be safe to be explicit!
3. @ManyToMany can now specify the name of the generated join table. Also they can point to themselves (i.e. User_User). Also can configure saveForeignKeyModels() for each generated @ForeignKey.
4. @ContentProvider generated now call down directly to the corresponding database methods. This is to simplify and prevent most other issues from coming up.
5. Now there's an incubating dbflow-kotlinextensions! It provides some Kotlin language features such as items.processInTransactionAsync { it.save() } or 5.property.eq(SomeTable_Table.num)
6. Migration no longer require empty constructor, but also support, since this led to hard-to-find compile time errors for some people:

    public TestMigration(Class<TestModel1> table) {
        super(table);
    }

1. Versions of 3.0.0-beta1 - 3.0.0-beta3 incorrectly created tables that specified autoincrement=true. What happened is that it treated them like a ROWID. This is fixed in this version, and to fix it for any existing table, you must include and subclass the included migration snippet here. It will run a one-time migration check if you had used this in earlier versions of the 3.0 lib. If it doesn't affect you or seem to notice, a new rowID param has been added to the @PrimaryKey annotation that will keep the existing way (to prevent inconsistencies).
2. all wrapper queries now have access to hasData() which returns count() > 0.
3. All saving, updating, deleting, and inserting is now done via a configurable ModelSaver class. All corresponding SqlUtils static methods have been deprecated. To specify your own subclass for any extra behavior:

FlowManager.getModelAdapter(SomeTable.class).setModelSaver(new MySubclassModelSaver());

// this might need to get configured for the corresponding `ModelContainerAdapter` if you use `@ModelContainer`.
FlowManager.getContainerAdapter(SomeTable.class).setModelSaver(new MyModelContainerSubclassModelSaver());

1. Fix issues with TypeConverter that used Blob as its database class. Properly convert the blob to a hex string using a super-efficient algorithm.
2. Fixed null values as strings that would insert 'null' instead of the database NULL, which could lead to head-scratching why a query like SQLite.delete(SomeTable.class).where(SomeTable_Table.column.eq(null)).execute() would fail to delete in some scenarios.
3. _Table classes now give you access to an array of IProperty from the table via getAllColumnProperties(). Useful in queries or table information.
4. Can attached queries as properties now: SQLite.select(SQLite.select().from(SomeTable.class).where(..)).from(SomethingElse.class).... (SELECT (SELECT * From...))
5. Doc improvements, bug fixes and more.